vellum-ai 1.7.11__tar.gz → 1.7.13__tar.gz

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 1.7.11
+Version: 1.7.13
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/ee/vellum_ee/workflows/display/base.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 
 class WorkflowTriggerType(Enum):
     MANUAL = "MANUAL"
-    SLACK_MESSAGE = "SLACK_MESSAGE"
+    INTEGRATION = "INTEGRATION"
 
 
 def get_trigger_type_mapping() -> Dict[Type["BaseTrigger"], WorkflowTriggerType]:
@@ -30,11 +30,9 @@ def get_trigger_type_mapping() -> Dict[Type["BaseTrigger"], WorkflowTriggerType]
         Dictionary mapping trigger classes to their enum types
     """
     from vellum.workflows.triggers.manual import ManualTrigger
-    from vellum.workflows.triggers.slack import SlackTrigger
 
     return {
         ManualTrigger: WorkflowTriggerType.MANUAL,
-        SlackTrigger: WorkflowTriggerType.SLACK_MESSAGE,
     }
 
 

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -153,7 +153,9 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
 
     def _generate_function_tools(
         self,
-        function: Union[FunctionDefinition, Callable, DeploymentDefinition, Type["BaseWorkflow"]],
+        function: Union[
+            FunctionDefinition, Callable, DeploymentDefinition, Type["BaseWorkflow"], VellumIntegrationToolDefinition
+        ],
         index: int,
         display_context: WorkflowDisplayContext,
     ) -> JsonObject:

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -25,10 +25,11 @@ 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.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
-from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum.workflows.utils.uuids import get_trigger_id, uuid4_from_hash
 from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
 from vellum.workflows.vellum_client import create_vellum_client
 from vellum_ee.workflows.display.base import (
@@ -38,6 +39,7 @@ from vellum_ee.workflows.display.base import (
     WorkflowInputsDisplay,
     WorkflowMetaDisplay,
     WorkflowOutputDisplay,
+    WorkflowTriggerType,
     get_trigger_type_mapping,
 )
 from vellum_ee.workflows.display.editor.types import NodeDisplayData, NodeDisplayPosition
@@ -465,16 +467,21 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                     f"{edge.trigger_class.__name__} in the same workflow."
                 )
 
-        # Get the trigger type from the mapping
+        # Get the trigger type from the mapping, or check if it's a VellumIntegrationTrigger subclass
         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()."
-            )
+            # Check if it's a VellumIntegrationTrigger subclass
+
+            if issubclass(trigger_class, VellumIntegrationTrigger):
+                trigger_type = WorkflowTriggerType.INTEGRATION
+            else:
+                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(trigger_class.__qualname__)
+        trigger_id = get_trigger_id(trigger_class)
 
         # Serialize trigger attributes like node outputs
         attribute_references = trigger_class.attribute_references().values()

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-ai"
 
 [tool.poetry]
 name = "vellum-ai"
-version = "1.7.11"
+version = "1.7.13"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/__init__.py

@@ -31,6 +31,7 @@ from .client.types import (
     AudioPromptBlock,
     AudioVellumValue,
     AudioVellumValueRequest,
+    AuthTypeEnum,
     BaseOutput,
     BasicVectorizerIntfloatMultilingualE5Large,
     BasicVectorizerIntfloatMultilingualE5LargeRequest,
@@ -768,6 +769,7 @@ __all__ = [
     "AudioPromptBlock",
     "AudioVellumValue",
     "AudioVellumValueRequest",
+    "AuthTypeEnum",
     "BadRequestError",
     "BaseOutput",
     "BasicVectorizerIntfloatMultilingualE5Large",

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.7.11",
+            "User-Agent": "vellum-ai/1.7.13",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.7.11",
+            "X-Fern-SDK-Version": "1.7.13",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/client/types/__init__.py

@@ -27,6 +27,7 @@ from .audio_input_request import AudioInputRequest
 from .audio_prompt_block import AudioPromptBlock
 from .audio_vellum_value import AudioVellumValue
 from .audio_vellum_value_request import AudioVellumValueRequest
+from .auth_type_enum import AuthTypeEnum
 from .base_output import BaseOutput
 from .basic_vectorizer_intfloat_multilingual_e_5_large import BasicVectorizerIntfloatMultilingualE5Large
 from .basic_vectorizer_intfloat_multilingual_e_5_large_request import BasicVectorizerIntfloatMultilingualE5LargeRequest
@@ -747,6 +748,7 @@ __all__ = [
     "AudioPromptBlock",
     "AudioVellumValue",
     "AudioVellumValueRequest",
+    "AuthTypeEnum",
     "BaseOutput",
     "BasicVectorizerIntfloatMultilingualE5Large",
     "BasicVectorizerIntfloatMultilingualE5LargeRequest",

vellum_ai-1.7.13/src/vellum/client/types/auth_type_enum.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+AuthTypeEnum = typing.Union[typing.Literal["API_KEY", "OAUTH2"], typing.Any]

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/client/types/integration_name.py

@@ -16,6 +16,10 @@ IntegrationName = typing.Union[
         "GOOGLE_DRIVE",
         "GMAIL",
         "AIRTABLE",
+        "GAMMA",
+        "FIRECRAWL",
+        "PERPLEXITY",
+        "SERPAPI",
     ],
     typing.Any,
 ]

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/client/types/slim_integration_auth_config_read.py

@@ -4,6 +4,7 @@ import typing
 
 import pydantic
 from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .auth_type_enum import AuthTypeEnum
 from .integration_auth_config_integration import IntegrationAuthConfigIntegration
 from .integration_auth_config_integration_credential import IntegrationAuthConfigIntegrationCredential
 from .integration_credential_access_type import IntegrationCredentialAccessType
@@ -17,6 +18,7 @@ class SlimIntegrationAuthConfigRead(UniversalBaseModel):
     id: str
     integration: IntegrationAuthConfigIntegration
     integration_credentials: typing.Optional[typing.List[IntegrationAuthConfigIntegrationCredential]] = None
+    auth_type: typing.Optional[AuthTypeEnum] = None
     default_access_type: typing.Optional[IntegrationCredentialAccessType] = None
 
     if IS_PYDANTIC_V2:

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/client/types/vellum_error_code_enum.py

@@ -14,6 +14,7 @@ VellumErrorCodeEnum = typing.Union[
         "USER_DEFINED_ERROR",
         "WORKFLOW_CANCELLED",
         "NODE_CANCELLED",
+        "PROVIDER_QUOTA_EXCEEDED",
     ],
     typing.Any,
 ]

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/client/types/vellum_sdk_error_code_enum.py

@@ -14,6 +14,7 @@ VellumSdkErrorCodeEnum = typing.Union[
         "PROVIDER_CREDENTIALS_UNAVAILABLE",
         "INTEGRATION_CREDENTIALS_UNAVAILABLE",
         "PROVIDER_ERROR",
+        "PROVIDER_QUOTA_EXCEEDED",
         "USER_DEFINED_ERROR",
         "WORKFLOW_CANCELLED",
         "NODE_CANCELLED",

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/client/types/workflow_execution_event_error_code.py

@@ -15,6 +15,7 @@ WorkflowExecutionEventErrorCode = typing.Union[
         "LLM_PROVIDER",
         "INVALID_TEMPLATE",
         "INVALID_INPUTS",
+        "PROVIDER_QUOTA_EXCEEDED",
         "USER_DEFINED_ERROR",
     ],
     typing.Any,

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/client/types/workflow_execution_snapshotted_body.py

@@ -9,6 +9,7 @@ from .vellum_code_resource_definition import VellumCodeResourceDefinition
 
 class WorkflowExecutionSnapshottedBody(UniversalBaseModel):
     workflow_definition: VellumCodeResourceDefinition
+    edited_by: typing.Optional[VellumCodeResourceDefinition] = None
     state: typing.Dict[str, typing.Optional[typing.Any]]
 
     if IS_PYDANTIC_V2:

vellum_ai-1.7.13/src/vellum/types/auth_type_enum.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.auth_type_enum import *

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/workflows/events/workflow.py

@@ -3,13 +3,13 @@ from uuid import UUID
 from typing import TYPE_CHECKING, Any, Dict, Generic, Iterable, Literal, Optional, Type, Union
 from typing_extensions import TypeGuard
 
-from pydantic import SerializationInfo, field_serializer
+from pydantic import SerializationInfo, field_serializer, field_validator
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.errors import WorkflowError
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.references import ExternalInputReference
-from vellum.workflows.types.definition import serialize_type_encoder_with_id
+from vellum.workflows.types.definition import CodeResourceDefinition, serialize_type_encoder_with_id
 from vellum.workflows.types.generics import InputsType, OutputsType, StateType
 
 from .node import (
@@ -24,6 +24,7 @@ from .stream import WorkflowEventGenerator
 from .types import BaseEvent, default_serializer
 
 if TYPE_CHECKING:
+    from vellum.workflows.nodes.bases.base import BaseNode
     from vellum.workflows.workflows.base import BaseWorkflow
 
 logger = logging.getLogger(__name__)
@@ -207,11 +208,26 @@ class WorkflowExecutionResumedEvent(_BaseWorkflowEvent):
 
 class WorkflowExecutionSnapshottedBody(_BaseWorkflowExecutionBody, Generic[StateType]):
     state: StateType
+    edited_by: Optional[Type["BaseNode"]] = None
+
+    @field_validator("edited_by", mode="before")
+    @classmethod
+    def validate_edited_by(cls, value: Any) -> Any:
+        if value is None:
+            return None
+        value = CodeResourceDefinition.model_validate(value)
+        return value.decode()
 
     @field_serializer("state")
     def serialize_state(self, state: StateType, _info: Any) -> Dict[str, Any]:
         return default_serializer(state)
 
+    @field_serializer("edited_by")
+    def serialize_edited_by(self, edited_by: Optional[Type["BaseNode"]], _info: Any) -> Optional[Dict[str, Any]]:
+        if edited_by is None:
+            return None
+        return serialize_type_encoder_with_id(edited_by)
+
 
 class WorkflowExecutionSnapshottedEvent(_BaseWorkflowEvent, Generic[StateType]):
     name: Literal["workflow.execution.snapshotted"] = "workflow.execution.snapshotted"

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py

@@ -87,17 +87,20 @@ class BasePromptNode(BaseNode[StateType], Generic[StateType]):
             raise NodeException(
                 message=e.body.get("detail", "Provider credentials is missing or unavailable"),
                 code=WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE,
+                raw_data=e.body,
             )
 
         elif e.status_code and e.status_code >= 400 and e.status_code < 500 and isinstance(e.body, dict):
             raise NodeException(
                 message=e.body.get("detail", "Failed to execute Prompt"),
                 code=WorkflowErrorCode.INVALID_INPUTS,
+                raw_data=e.body,
             ) from e
 
         raise NodeException(
             message="Failed to execute Prompt",
             code=WorkflowErrorCode.INTERNAL_ERROR,
+            raw_data=e.body,
         ) from e
 
     def __directly_emit_workflow_output__(

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/workflows/nodes/displayable/inline_prompt_node/tests/test_node.py

@@ -197,6 +197,9 @@ def test_inline_prompt_node__api_error__invalid_inputs_node_exception(
     assert e.value.code == expected_code
     assert e.value.message == expected_message
 
+    # AND the node exception includes the response body in raw_data
+    assert e.value.raw_data == exception.body
+
 
 def test_inline_prompt_node__chat_history_inputs(vellum_adhoc_prompt_client):
     # GIVEN a prompt node with a chat history input

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/workflows/nodes/displayable/tool_calling_node/tests/test_node.py

@@ -426,3 +426,55 @@ def test_tool_node_preserves_node_exception():
     assert e.code == WorkflowErrorCode.INVALID_INPUTS
     assert e.raw_data == {"key": "value"}
     assert "Custom error" in e.message
+
+
+def test_tool_node_error_message_includes_function_name():
+    """Test that error messages include the actual function name, not 'wrapper'."""
+
+    # GIVEN a function that raises a regular exception
+    def my_tool_function() -> str:
+        raise ValueError("Something went wrong")
+
+    # AND a tool prompt node with that function
+    tool_prompt_node = create_tool_prompt_node(
+        ml_model="test-model",
+        blocks=[],
+        functions=[my_tool_function],
+        prompt_inputs=None,
+        parameters=DEFAULT_PROMPT_PARAMETERS,
+    )
+
+    function_node_class = create_function_node(
+        function=my_tool_function,
+        tool_prompt_node=tool_prompt_node,
+    )
+
+    # AND a state with a function call
+    state = ToolCallingState(
+        meta=StateMeta(
+            node_outputs={
+                tool_prompt_node.Outputs.results: [
+                    FunctionCallVellumValue(
+                        value=FunctionCall(
+                            arguments={},
+                            id="call_456",
+                            name="my_tool_function",
+                            state="FULFILLED",
+                        ),
+                    )
+                ],
+            },
+        )
+    )
+
+    function_node = function_node_class(state=state)
+
+    # WHEN the function node runs and raises an exception
+    with pytest.raises(NodeException) as exc_info:
+        list(function_node.run())
+
+    # THEN the error message should include the actual function name
+    e = exc_info.value
+    assert "my_tool_function" in e.message
+    assert "wrapper" not in e.message.lower()
+    assert "Something went wrong" in e.message

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -550,6 +550,8 @@ def create_function_node(
 
                 return func(**merged_kwargs)
 
+            # Preserve the original function name for better error messages
+            wrapper.__name__ = func.__name__
             return wrapper
 
         node = type(

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/workflows/references/trigger.py

@@ -11,6 +11,7 @@ from pydantic_core import core_schema
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
+from vellum.workflows.utils.uuids import get_trigger_attribute_id
 
 if TYPE_CHECKING:
     from vellum.workflows.state.base import BaseState
@@ -39,15 +40,8 @@ class TriggerAttributeReference(BaseDescriptor[_T], Generic[_T]):
 
     @property
     def id(self) -> UUID:
-        attribute_ids = getattr(self._trigger_class, "__trigger_attribute_ids__", {})
-        attribute_id = attribute_ids.get(self.name)
-        if isinstance(attribute_id, UUID):
-            return attribute_id
-
-        raise RuntimeError(
-            "Trigger attribute identifiers must be generated at class creation time. "
-            f"Attribute '{self.name}' is not registered on {self._trigger_class.__qualname__}."
-        )
+        """Generate deterministic UUID from trigger class qualname and attribute name."""
+        return get_trigger_attribute_id(self._trigger_class, self.name)
 
     def resolve(self, state: BaseState) -> _T:
         trigger_attributes = getattr(state.meta, "trigger_attributes", {})

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/workflows/runner/runner.py

@@ -275,6 +275,11 @@ class WorkflowRunner(Generic[StateType]):
             httpx_logger.removeFilter(span_filter)
 
     def _snapshot_state(self, state: StateType, deltas: List[StateDelta]) -> StateType:
+        execution = get_execution_context()
+        edited_by = None
+        if execution.parent_context and hasattr(execution.parent_context, "node_definition"):
+            edited_by = execution.parent_context.node_definition
+
         self._workflow_event_inner_queue.put(
             WorkflowExecutionSnapshottedEvent(
                 trace_id=self._execution_context.trace_id,
@@ -282,6 +287,7 @@ class WorkflowRunner(Generic[StateType]):
                 body=WorkflowExecutionSnapshottedBody(
                     workflow_definition=self.workflow.__class__,
                     state=state,
+                    edited_by=edited_by,
                 ),
                 parent=self._execution_context.parent_context,
             )
@@ -456,14 +462,14 @@ class WorkflowRunner(Generic[StateType]):
 
             node.state.meta.node_execution_cache.fulfill_node_execution(node.__class__, span_id)
 
-            with node.state.__atomic__():
-                for descriptor, output_value in outputs:
-                    if output_value is undefined:
-                        if descriptor in node.state.meta.node_outputs:
-                            del node.state.meta.node_outputs[descriptor]
-                        continue
-
-                    node.state.meta.node_outputs[descriptor] = output_value
+            with execution_context(parent_context=updated_parent_context, trace_id=execution.trace_id):
+                with node.state.__atomic__():
+                    for descriptor, output_value in outputs:
+                        if output_value is undefined:
+                            if descriptor in node.state.meta.node_outputs:
+                                del node.state.meta.node_outputs[descriptor]
+                            continue
+                        node.state.meta.node_outputs[descriptor] = output_value
 
             invoked_ports = ports(outputs, node.state)
             yield NodeExecutionFulfilledEvent(

vellum_ai-1.7.13/src/vellum/workflows/tests/triggers/test_vellum_integration_trigger.py

@@ -0,0 +1,183 @@
+"""Tests for VellumIntegrationTrigger."""
+
+import pytest
+
+from vellum.workflows.constants import VellumIntegrationProviderType
+from vellum.workflows.references.trigger import TriggerAttributeReference
+from vellum.workflows.triggers.vellum_integration import VellumIntegrationTrigger
+
+
+def test_requires_config():
+    """Trigger classes must declare Config with required fields."""
+
+    # This should fail - no Config class
+    with pytest.raises(TypeError, match="Config"):
+
+        class BadTrigger1(VellumIntegrationTrigger):
+            message: str
+            # Missing Config!
+
+    # This should fail - incomplete Config
+    with pytest.raises(TypeError, match="provider"):
+
+        class BadTrigger2(VellumIntegrationTrigger):
+            message: str
+
+            class Config(VellumIntegrationTrigger.Config):
+                integration_name = "SLACK"
+                slug = "slack_new_message"
+                # Missing provider!
+
+    # This should work
+    class GoodTrigger(VellumIntegrationTrigger):
+        message: str
+        user: str
+
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    assert hasattr(GoodTrigger, "Config")
+
+
+def test_top_level_annotations_create_references():
+    """Top-level type annotations (webhook event attributes) automatically create TriggerAttributeReference."""
+
+    class SlackTrigger(VellumIntegrationTrigger):
+        message: str
+        user: str
+        timestamp: float
+
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    # Should auto-create references from annotations
+    assert isinstance(SlackTrigger.message, TriggerAttributeReference)
+    assert isinstance(SlackTrigger.user, TriggerAttributeReference)
+    assert isinstance(SlackTrigger.timestamp, TriggerAttributeReference)
+    assert SlackTrigger.message.types == (str,)
+    assert SlackTrigger.timestamp.types == (float,)
+
+    # Undeclared attributes should raise AttributeError
+    with pytest.raises(AttributeError):
+        _ = SlackTrigger.undefined_attribute
+
+
+def test_attribute_ids_include_class_name():
+    """Attribute IDs should include class name (like nodes)."""
+
+    class Trigger1(VellumIntegrationTrigger):
+        message: str
+
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    class Trigger2(VellumIntegrationTrigger):
+        message: str
+
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    # Different class names = different IDs (like nodes)
+    # Type ignore: mypy sees message as str, but it's actually TriggerAttributeReference at class level
+    assert Trigger1.message.id != Trigger2.message.id  # type: ignore[attr-defined]
+
+
+def test_populates_dynamic_attributes():
+    """Trigger dynamically populates attributes from event_data keys."""
+
+    class GithubPushTrigger(VellumIntegrationTrigger):
+        repository: str
+        branch: str
+        commits: list
+
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "GITHUB"
+            slug = "github_push_event"
+
+    event_data = {
+        "repository": "vellum-ai/workflows",
+        "branch": "main",
+        "commits": ["abc123", "def456"],
+    }
+
+    trigger = GithubPushTrigger(event_data=event_data)
+
+    assert trigger.repository == "vellum-ai/workflows"
+    assert trigger.branch == "main"
+    assert trigger.commits == ["abc123", "def456"]
+
+
+def test_to_trigger_attribute_values():
+    """to_trigger_attribute_values returns correct attribute mappings."""
+
+    class SlackTrigger(VellumIntegrationTrigger):
+        message: str
+        channel: str
+
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    event_data = {"message": "Hello", "channel": "C123"}
+    trigger = SlackTrigger(event_data=event_data)
+
+    attr_values = trigger.to_trigger_attribute_values()
+
+    assert len(attr_values) == 2
+    for key in attr_values.keys():
+        assert isinstance(key, TriggerAttributeReference)
+    assert set(attr_values.values()) == {"Hello", "C123"}
+
+
+def test_to_exec_config():
+    """to_exec_config() produces valid ComposioIntegrationTriggerExecConfig."""
+
+    class SlackTrigger(VellumIntegrationTrigger):
+        message: str
+        user: str
+
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    exec_config = SlackTrigger.to_exec_config()
+
+    assert exec_config.type == "INTEGRATION"
+    assert exec_config.provider == VellumIntegrationProviderType.COMPOSIO
+    assert exec_config.integration_name == "SLACK"
+    assert exec_config.slug == "slack_new_message"
+    assert exec_config.event_attributes == {"message": str, "user": str}
+
+
+def test_to_exec_config_base_class_fails():
+    """to_exec_config() raises error on base class."""
+    with pytest.raises(AttributeError):
+        VellumIntegrationTrigger.to_exec_config()
+
+
+def test_empty_event_data():
+    """Trigger handles empty event data gracefully."""
+
+    class SlackTrigger(VellumIntegrationTrigger):
+        message: str
+
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    trigger = SlackTrigger(event_data={})
+
+    attr_values = trigger.to_trigger_attribute_values()
+    assert attr_values == {}

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/workflows/triggers/__init__.py

@@ -1,7 +1,6 @@
 from vellum.workflows.triggers.base import BaseTrigger
 from vellum.workflows.triggers.integration import IntegrationTrigger
 from vellum.workflows.triggers.manual import ManualTrigger
-from vellum.workflows.triggers.slack import SlackTrigger
 from vellum.workflows.triggers.vellum_integration import VellumIntegrationTrigger
 
-__all__ = ["BaseTrigger", "IntegrationTrigger", "ManualTrigger", "SlackTrigger", "VellumIntegrationTrigger"]
+__all__ = ["BaseTrigger", "IntegrationTrigger", "ManualTrigger", "VellumIntegrationTrigger"]

{vellum_ai-1.7.11 → vellum_ai-1.7.13}/src/vellum/workflows/triggers/tests/test_integration.py

@@ -57,8 +57,8 @@ def test_integration_trigger__attribute_reference():
     reference = TestTrigger.value
     assert isinstance(reference, TriggerAttributeReference)
     assert reference.name == "value"
-    assert TestTrigger.value is reference
-    assert reference is TestTrigger.attribute_references()["value"]
+    assert TestTrigger.value == reference
+    assert reference == TestTrigger.attribute_references()["value"]
 
     state = BaseState()
     trigger = TestTrigger({"value": "data"})