vellum-ai 1.8.6__py3-none-any.whl → 1.9.0__py3-none-any.whl

vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -25,8 +25,8 @@ from vellum.workflows.nodes.utils import get_unadorned_node, get_unadorned_port,
 from vellum.workflows.ports import Port
 from vellum.workflows.references import OutputReference, WorkflowInputReference
 from vellum.workflows.state.encoder import DefaultStateEncoder
+from vellum.workflows.triggers.integration import IntegrationTrigger
 from vellum.workflows.triggers.manual import ManualTrigger
-from vellum.workflows.triggers.vellum_integration import VellumIntegrationTrigger
 from vellum.workflows.types.core import Json, JsonArray, JsonObject
 from vellum.workflows.types.generics import WorkflowType
 from vellum.workflows.types.utils import get_original_base
@@ -190,7 +190,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
         # For IntegrationTrigger only: no ENTRYPOINT node (use trigger ID directly in edges)
         manual_trigger_edges = [edge for edge in trigger_edges if issubclass(edge.trigger_class, ManualTrigger)]
         integration_trigger_edges = [
-            edge for edge in trigger_edges if issubclass(edge.trigger_class, VellumIntegrationTrigger)
+            edge for edge in trigger_edges if issubclass(edge.trigger_class, IntegrationTrigger)
         ]
 
         has_manual_trigger = len(manual_trigger_edges) > 0
@@ -536,12 +536,12 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                     f"{edge.trigger_class.__name__} in the same workflow."
                 )
 
-        # Get the trigger type from the mapping, or check if it's a VellumIntegrationTrigger subclass
+        # Get the trigger type from the mapping, or check if it's an IntegrationTrigger subclass
         trigger_type = trigger_type_mapping.get(trigger_class)
         if trigger_type is None:
-            # Check if it's a VellumIntegrationTrigger subclass
+            # Check if it's an IntegrationTrigger subclass
 
-            if issubclass(trigger_class, VellumIntegrationTrigger):
+            if issubclass(trigger_class, IntegrationTrigger):
                 trigger_type = WorkflowTriggerType.INTEGRATION
             else:
                 raise ValueError(

vellum_ee/workflows/server/virtual_file_loader.py

@@ -85,13 +85,11 @@ class VirtualFileLoader(importlib.abc.Loader):
 
     def _is_package_directory(self, fullname: str) -> bool:
         """Check if directory contains .py files that should be treated as a package."""
-        directory_prefix = fullname.replace(".", "/") + "/"
-
-        # Exclude top-level display directory from auto-generation as it typically has
-        # specific __init__.py content that shouldn't be replaced with empty files.
-        if directory_prefix == "display/":
-            return False
+        if fullname == "":
+            # This is the root namespace, so it's a package directory
+            return True
 
+        directory_prefix = fullname.replace(".", "/") + "/"
         for file_path in self.files.keys():
             if file_path.startswith(directory_prefix):
                 if file_path.endswith(".py") and not file_path.endswith("__init__.py"):
@@ -104,10 +102,40 @@ class VirtualFileLoader(importlib.abc.Loader):
 
     def _generate_init_content(self, fullname: str) -> tuple[str, str]:
         """Auto-generate empty __init__.py content to mark directory as a package."""
+        if fullname == "":
+            if any(file_path.startswith("display/") for file_path in self.files.keys()):
+                return (
+                    "__init__.py",
+                    """\
+from .display import *
+""",
+                )
+            else:
+                return "__init__.py", ""
+
         directory_prefix = fullname.replace(".", "/") + "/"
         file_path = directory_prefix + "__init__.py"
 
-        code = ""
+        if not fullname.startswith("display"):
+            return "__init__.py", ""
+
+        # We have to go through the effort of exhaustively importing all display modules, because that's how
+        # dynamically annotate our Workflow graph.
+        all_nested_files = [
+            file_path[len(directory_prefix) :]
+            for file_path in self.files.keys()
+            if file_path.startswith(directory_prefix)
+        ]
+
+        top_level_items = {file_path.split("/")[0] for file_path in all_nested_files}
+
+        top_level_modules = [
+            re.sub(r"\.py$", "", file_path)
+            for file_path in top_level_items
+            if file_path.endswith(".py") or "." not in file_path
+        ]
+
+        code = "\n".join([f"from .{file_path} import *" for file_path in top_level_modules])
 
         return file_path, code
 
@@ -126,7 +154,7 @@ class VirtualFileFinder(BaseWorkflowFinder):
 
     def find_spec(self, fullname: str, path, target=None):
         module_info = self.loader._resolve_module(fullname)
-        if module_info:
+        if isinstance(module_info, tuple) and len(module_info) == 2:
             file_path, _ = module_info
             is_package = file_path.endswith("__init__.py")
             return importlib.machinery.ModuleSpec(

vellum_ee/workflows/tests/test_server.py

@@ -1,17 +1,19 @@
 import pytest
 import sys
-from uuid import uuid4
+from uuid import UUID, uuid4
 from typing import Type, cast
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.code_executor_response import CodeExecutorResponse
 from vellum.client.types.number_vellum_value import NumberVellumValue
 from vellum.workflows import BaseWorkflow
+from vellum.workflows.events.workflow import WorkflowExecutionInitiatedBody
 from vellum.workflows.exceptions import WorkflowInitializationException
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.utils.uuids import generate_workflow_deployment_prefix
 from vellum.workflows.utils.zip import zip_file_map
+from vellum_ee.workflows.display.utils.events import event_enricher
 from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 from vellum_ee.workflows.server.virtual_file_loader import VirtualFileFinder
 
@@ -27,7 +29,6 @@ def test_load_workflow_event_display_context():
 def test_load_from_module__lazy_reference_in_file_loader():
     # GIVEN a workflow module with a node containing a lazy reference
     files = {
-        "__init__.py": "",
         "workflow.py": """\
 from vellum.workflows import BaseWorkflow
 from .nodes.start_node import StartNode
@@ -902,3 +903,81 @@ class TestSubworkflowDeploymentNode(SubworkflowDeploymentNode):
 
     # AND the X-Vellum-Always-Success header should be included for graceful error handling
     assert kwargs["request_options"]["additional_headers"]["X-Vellum-Always-Success"] == "true"
+
+
+def test_workflow_initiated_event_includes_display_context_with_output_display_name():
+    """
+    Tests that workflow initiated events include display context with annotated node and output information.
+    """
+    # GIVEN a workflow with a single node that has a single output
+    files = {
+        "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from .nodes.start_node import StartNode
+
+class Workflow(BaseWorkflow):
+    graph = StartNode
+
+    class Outputs(BaseWorkflow.Outputs):
+        final_result = StartNode.Outputs.result
+""",
+        "nodes/start_node.py": """\
+from vellum.workflows.nodes import BaseNode
+
+class StartNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        result: str = "test output"
+""",
+        "display/nodes/__init__.py": """\
+from .start_node import StartNodeDisplay
+""",
+        "display/nodes/start_node.py": """\
+from uuid import UUID
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
+from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
+from ...nodes.start_node import StartNode
+
+class StartNodeDisplay(BaseNodeDisplay[StartNode]):
+    node_id = UUID("11111111-1111-1111-1111-111111111111")
+    output_display = {
+        StartNode.Outputs.result: NodeOutputDisplay(
+            id=UUID("22222222-2222-2222-2222-222222222222"),
+            name="Pretty Result"
+        )
+    }
+""",
+        "display/workflow.py": """\
+""",
+    }
+
+    namespace = str(uuid4())
+    finder = VirtualFileFinder(files, namespace)
+    sys.meta_path.append(finder)
+
+    try:
+        # WHEN we stream the workflow and enrich the initiated event with display context
+        Workflow = BaseWorkflow.load_from_module(namespace)
+        workflow = Workflow()
+        initiated_event = list(workflow.stream())[0]
+        enriched_event = event_enricher(initiated_event)
+
+        # THEN the initiated event should have display context
+        assert isinstance(enriched_event.body, WorkflowExecutionInitiatedBody)
+        body = enriched_event.body
+        assert body.display_context is not None
+
+        # AND the display context should contain the annotated node
+        node_displays = body.display_context.node_displays
+        annotated_node_id = UUID("11111111-1111-1111-1111-111111111111")
+        assert annotated_node_id in node_displays
+
+        # AND the node's output display should contain the output with the display name "Pretty Result"
+        node_display = node_displays[annotated_node_id]
+        assert "result" in node_display.output_display
+
+        # AND the output should map to the annotated output id
+        annotated_output_id = UUID("22222222-2222-2222-2222-222222222222")
+        assert node_display.output_display["result"] == annotated_output_id
+    finally:
+        if finder in sys.meta_path:
+            sys.meta_path.remove(finder)

vellum_ee/workflows/tests/test_virtual_files.py

@@ -121,12 +121,9 @@ class WorkflowDisplay(BaseWorkflowDisplay):
 
         spec = importlib.util.find_spec(f"{namespace}.display")
 
-        # THEN the spec should be None because we don't want to auto-generate display/__init__.py
-        # If the spec exists, it means an empty __init__.py was auto-generated (BAD)
-        assert spec is None, (
-            "display directory should NOT have auto-generated __init__.py. "
-            "Display directories require specific __init__.py content that shouldn't be empty."
-        )
+        # THEN the spec should be found because we now support dynamic display module imports
+        assert spec
+        assert spec.origin == "display/__init__.py"
 
     finally:
         # Clean up

vellum/workflows/triggers/vellum_integration.py

@@ -1,189 +0,0 @@
-from typing import Any, ClassVar, Dict
-
-from vellum.workflows.constants import VellumIntegrationProviderType
-from vellum.workflows.references.trigger import TriggerAttributeReference
-from vellum.workflows.triggers.base import BaseTriggerMeta
-from vellum.workflows.triggers.integration import IntegrationTrigger
-
-
-class VellumIntegrationTriggerMeta(BaseTriggerMeta):
-    """
-    Custom metaclass for VellumIntegrationTrigger.
-
-    This metaclass extends BaseTriggerMeta to automatically convert type annotations
-    into TriggerAttributeReference objects during class creation. This enables trigger
-    attributes to be referenced in workflow graphs while maintaining type safety.
-    """
-
-    def __new__(mcs, name: str, bases: tuple, namespace: dict, **kwargs: Any) -> "VellumIntegrationTriggerMeta":
-        """Create a new trigger class and set up attribute references."""
-        cls = super().__new__(mcs, name, bases, namespace, **kwargs)
-
-        # Process __annotations__ to create TriggerAttributeReference for each attribute
-        # Only process if class has Config and annotations
-        has_config = hasattr(cls, "Config") and "Config" in namespace
-        if has_config and hasattr(cls, "__annotations__"):
-            # Create TriggerAttributeReference for each annotated attribute
-            for attr_name, attr_type in cls.__annotations__.items():
-                # Skip special attributes and Config
-                if attr_name.startswith("_") or attr_name == "Config":
-                    continue
-
-                # Create reference with proper type
-                reference = TriggerAttributeReference(
-                    name=attr_name, types=(attr_type,), instance=None, trigger_class=cls
-                )
-                # Set as class attribute so it's directly accessible
-                setattr(cls, attr_name, reference)
-
-        return cls
-
-
-class VellumIntegrationTrigger(IntegrationTrigger, metaclass=VellumIntegrationTriggerMeta):
-    """
-    Base class for Vellum-managed integration triggers.
-
-    Subclasses define two types of attributes:
-    1. **Config class**: Specifies how the trigger is configured (provider, integration_name, slug)
-       - These are configuration details users shouldn't need to interact with directly
-    2. **Top-level type annotations**: Define the webhook event payload structure (message, user, channel, etc.)
-       - These become TriggerAttributeReference that can be referenced in workflow nodes
-
-    Examples:
-        Create a Slack trigger:
-            >>> class SlackNewMessageTrigger(VellumIntegrationTrigger):
-            ...     # Event attributes (webhook payload structure)
-            ...     message: str
-            ...     user: str
-            ...     channel: str
-            ...     timestamp: float
-            ...
-            ...     # Configuration (how trigger is set up)
-            ...     class Config(VellumIntegrationTrigger.Config):
-            ...         provider = VellumIntegrationProviderType.COMPOSIO
-            ...         integration_name = "SLACK"
-            ...         slug = "slack_new_message"
-
-        Use in workflow graph:
-            >>> class MyWorkflow(BaseWorkflow):
-            ...     graph = SlackNewMessageTrigger >> ProcessMessageNode
-
-        Reference trigger attributes in nodes:
-            >>> class ProcessNode(BaseNode):
-            ...     class Outputs(BaseNode.Outputs):
-            ...         text = SlackNewMessageTrigger.message
-            ...         channel = SlackNewMessageTrigger.channel
-
-        Instantiate for testing:
-            >>> trigger = SlackNewMessageTrigger(event_data={
-            ...     "message": "Hello world",
-            ...     "channel": "C123456",
-            ...     "user": "U123",
-            ...     "timestamp": 1234567890.0,
-            ... })
-            >>> trigger.message
-            'Hello world'
-    """
-
-    class Config:
-        """
-        Configuration for VellumIntegrationTrigger subclasses.
-
-        Defines how the trigger connects to the integration provider. These settings
-        specify which integration and which specific trigger type to use.
-        """
-
-        provider: ClassVar[VellumIntegrationProviderType]
-        integration_name: ClassVar[str]
-        slug: ClassVar[str]
-
-    def __init_subclass__(cls, **kwargs: Any) -> None:
-        """Validate that subclasses define required Config class with all required fields."""
-        super().__init_subclass__(**kwargs)
-
-        # Skip validation for the base class itself
-        if cls.__name__ == "VellumIntegrationTrigger":
-            return
-
-        # Require Config class with required fields
-        if not hasattr(cls, "Config") or cls.Config is VellumIntegrationTrigger.Config:
-            raise TypeError(
-                f"{cls.__name__} must define a nested Config class. "
-                f"Example:\n"
-                f"  class {cls.__name__}(VellumIntegrationTrigger):\n"
-                f"      message: str\n"
-                f"      class Config(VellumIntegrationTrigger.Config):\n"
-                f"          provider = VellumIntegrationProviderType.COMPOSIO\n"
-                f"          integration_name = 'SLACK'\n"
-                f"          slug = 'slack_new_message'"
-            )
-
-        # Validate Config class has required fields
-        config_cls = cls.Config
-        required_fields = ["provider", "integration_name", "slug"]
-        for field in required_fields:
-            if not hasattr(config_cls, field):
-                raise TypeError(
-                    f"{cls.__name__}.Config must define '{field}'. " f"Required fields: {', '.join(required_fields)}"
-                )
-
-    def __init__(self, event_data: dict):
-        """
-        Initialize trigger with event data from the integration.
-
-        The trigger dynamically populates its attributes based on the event_data
-        dictionary keys. Any key in event_data becomes an accessible attribute.
-
-        Args:
-            event_data: Raw event data from the integration. Keys become trigger attributes.
-
-        Examples:
-            >>> class SlackTrigger(VellumIntegrationTrigger):
-            ...     message: str
-            ...     channel: str
-            ...     user: str
-            ...
-            ...     class Config(VellumIntegrationTrigger.Config):
-            ...         provider = VellumIntegrationProviderType.COMPOSIO
-            ...         integration_name = "SLACK"
-            ...         slug = "slack_new_message"
-            >>> trigger = SlackTrigger(event_data={
-            ...     "message": "Hello",
-            ...     "channel": "C123",
-            ...     "user": "U456"
-            ... })
-            >>> trigger.message
-            'Hello'
-            >>> trigger.channel
-            'C123'
-        """
-        super().__init__(event_data)
-
-        # Dynamically populate instance attributes from event_data.
-        # This allows any key in event_data to become an accessible attribute:
-        # event_data={"message": "Hi"} → trigger.message == "Hi"
-        for key, value in event_data.items():
-            setattr(self, key, value)
-
-    def to_trigger_attribute_values(self) -> Dict["TriggerAttributeReference[Any]", Any]:
-        """
-        Materialize attribute descriptor/value pairs for this trigger instance.
-
-        For VellumIntegrationTrigger, this includes all dynamic attributes from event_data.
-        """
-        attribute_values: Dict["TriggerAttributeReference[Any]", Any] = {}
-
-        # Unlike the base class which iterates over type(self) (predefined annotations),
-        # we iterate over event_data keys since our attributes are discovered dynamically
-        # from the actual event data received during workflow execution.
-        # The base class approach: for reference in type(self)
-        # Our approach: for attr_name in self._event_data.keys()
-        for attr_name in self._event_data.keys():
-            # Get the class-level reference for this attribute (created by __new__ from annotations)
-            # Unknown keys can appear in webhook payloads, so gracefully skip them if the
-            # trigger class doesn't expose a corresponding reference.
-            reference = getattr(type(self), attr_name, None)
-            if isinstance(reference, TriggerAttributeReference):
-                attribute_values[reference] = getattr(self, attr_name)
-
-        return attribute_values