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

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.6",
+            "User-Agent": "vellum-ai/1.7.8",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.7.6",
+            "X-Fern-SDK-Version": "1.7.8",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

vellum/client/reference.md

@@ -4566,6 +4566,22 @@ client.integration_providers.list_integration_tools(
 <dl>
 <dd>
 
+**important:** `typing.Optional[bool]` — Whether to filter the tools by important
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**include_deprecated:** `typing.Optional[bool]` — Whether to include deprecated tools
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
 **integration_name:** `typing.Optional[str]` — The Vellum Integration name
     
 </dd>

vellum/client/resources/ad_hoc/raw_client.py

@@ -73,7 +73,7 @@ class RawAdHocClient:
         """
         _response = self._client_wrapper.httpx_client.request(
             "v1/ad-hoc/execute-prompt",
-            base_url=self._client_wrapper.get_environment().default,
+            base_url=self._client_wrapper.get_environment().predict,
             method="POST",
             json={
                 "ml_model": ml_model,
@@ -344,7 +344,7 @@ class AsyncRawAdHocClient:
         """
         _response = await self._client_wrapper.httpx_client.request(
             "v1/ad-hoc/execute-prompt",
-            base_url=self._client_wrapper.get_environment().default,
+            base_url=self._client_wrapper.get_environment().predict,
             method="POST",
             json={
                 "ml_model": ml_model,

vellum/client/resources/integration_providers/client.py

@@ -81,6 +81,8 @@ class IntegrationProvidersClient:
         self,
         integration_provider: str,
         *,
+        important: typing.Optional[bool] = None,
+        include_deprecated: typing.Optional[bool] = None,
         integration_name: typing.Optional[str] = None,
         limit: typing.Optional[int] = None,
         offset: typing.Optional[int] = None,
@@ -95,6 +97,12 @@ class IntegrationProvidersClient:
         integration_provider : str
             The integration provider name
 
+        important : typing.Optional[bool]
+            Whether to filter the tools by important
+
+        include_deprecated : typing.Optional[bool]
+            Whether to include deprecated tools
+
         integration_name : typing.Optional[str]
             The Vellum Integration name
 
@@ -129,6 +137,8 @@ class IntegrationProvidersClient:
         """
         _response = self._raw_client.list_integration_tools(
             integration_provider,
+            important=important,
+            include_deprecated=include_deprecated,
             integration_name=integration_name,
             limit=limit,
             offset=offset,
@@ -214,6 +224,8 @@ class AsyncIntegrationProvidersClient:
         self,
         integration_provider: str,
         *,
+        important: typing.Optional[bool] = None,
+        include_deprecated: typing.Optional[bool] = None,
         integration_name: typing.Optional[str] = None,
         limit: typing.Optional[int] = None,
         offset: typing.Optional[int] = None,
@@ -228,6 +240,12 @@ class AsyncIntegrationProvidersClient:
         integration_provider : str
             The integration provider name
 
+        important : typing.Optional[bool]
+            Whether to filter the tools by important
+
+        include_deprecated : typing.Optional[bool]
+            Whether to include deprecated tools
+
         integration_name : typing.Optional[str]
             The Vellum Integration name
 
@@ -270,6 +288,8 @@ class AsyncIntegrationProvidersClient:
         """
         _response = await self._raw_client.list_integration_tools(
             integration_provider,
+            important=important,
+            include_deprecated=include_deprecated,
             integration_name=integration_name,
             limit=limit,
             offset=offset,

vellum/client/resources/integration_providers/raw_client.py

@@ -72,6 +72,8 @@ class RawIntegrationProvidersClient:
         self,
         integration_provider: str,
         *,
+        important: typing.Optional[bool] = None,
+        include_deprecated: typing.Optional[bool] = None,
         integration_name: typing.Optional[str] = None,
         limit: typing.Optional[int] = None,
         offset: typing.Optional[int] = None,
@@ -86,6 +88,12 @@ class RawIntegrationProvidersClient:
         integration_provider : str
             The integration provider name
 
+        important : typing.Optional[bool]
+            Whether to filter the tools by important
+
+        include_deprecated : typing.Optional[bool]
+            Whether to include deprecated tools
+
         integration_name : typing.Optional[str]
             The Vellum Integration name
 
@@ -111,6 +119,8 @@ class RawIntegrationProvidersClient:
             base_url=self._client_wrapper.get_environment().default,
             method="GET",
             params={
+                "important": important,
+                "include_deprecated": include_deprecated,
                 "integration_name": integration_name,
                 "limit": limit,
                 "offset": offset,
@@ -193,6 +203,8 @@ class AsyncRawIntegrationProvidersClient:
         self,
         integration_provider: str,
         *,
+        important: typing.Optional[bool] = None,
+        include_deprecated: typing.Optional[bool] = None,
         integration_name: typing.Optional[str] = None,
         limit: typing.Optional[int] = None,
         offset: typing.Optional[int] = None,
@@ -207,6 +219,12 @@ class AsyncRawIntegrationProvidersClient:
         integration_provider : str
             The integration provider name
 
+        important : typing.Optional[bool]
+            Whether to filter the tools by important
+
+        include_deprecated : typing.Optional[bool]
+            Whether to include deprecated tools
+
         integration_name : typing.Optional[str]
             The Vellum Integration name
 
@@ -232,6 +250,8 @@ class AsyncRawIntegrationProvidersClient:
             base_url=self._client_wrapper.get_environment().default,
             method="GET",
             params={
+                "important": important,
+                "include_deprecated": include_deprecated,
                 "integration_name": integration_name,
                 "limit": limit,
                 "offset": offset,

vellum/client/types/integration_name.py

@@ -15,6 +15,7 @@ IntegrationName = typing.Union[
         "GOOGLE_CALENDAR",
         "GOOGLE_DRIVE",
         "GMAIL",
+        "AIRTABLE",
     ],
     typing.Any,
 ]

vellum/client/types/workflow_execution_fulfilled_body.py

@@ -10,6 +10,7 @@ from .vellum_code_resource_definition import VellumCodeResourceDefinition
 class WorkflowExecutionFulfilledBody(UniversalBaseModel):
     workflow_definition: VellumCodeResourceDefinition
     outputs: typing.Dict[str, typing.Optional[typing.Any]]
+    final_state: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/workflows/nodes/bases/base_adornment_node.py

@@ -1,10 +1,12 @@
 from abc import ABC
-from typing import TYPE_CHECKING, Any, Dict, Generic, Optional, Tuple, Type
+from uuid import UUID
+from typing import TYPE_CHECKING, Any, Dict, Generic, Optional, Set, Tuple, Type
 
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode, BaseNodeMeta
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.references.output import OutputReference
+from vellum.workflows.types.core import MergeBehavior
 from vellum.workflows.types.generics import StateType
 
 if TYPE_CHECKING:
@@ -79,6 +81,56 @@ class BaseAdornmentNode(
     __wrapped_node__: Optional[Type["BaseNode"]] = None
     subworkflow: Type["BaseWorkflow"]
 
+    class Trigger(BaseNode.Trigger):
+        """
+        Trigger class for adornment nodes that delegates to the wrapped node's Trigger
+        for proper merge behavior handling.
+        """
+
+        @classmethod
+        def should_initiate(
+            cls,
+            state: StateType,
+            dependencies: Set["Type[BaseNode]"],
+            node_span_id: UUID,
+        ) -> bool:
+            """
+            Delegates to the wrapped node's Trigger.should_initiate method to ensure
+            proper merge behavior (like AWAIT_ALL) is respected for initiation logic.
+            """
+            # Get the wrapped node's Trigger class
+            wrapped_node = cls.node_class.__wrapped_node__
+            if wrapped_node is not None:
+                wrapped_trigger = wrapped_node.Trigger
+                # Only delegate if the wrapped node has a specific merge behavior
+                # that differs from the default AWAIT_ATTRIBUTES
+                if (
+                    hasattr(wrapped_trigger, "merge_behavior")
+                    and wrapped_trigger.merge_behavior != MergeBehavior.AWAIT_ATTRIBUTES
+                ):
+                    return wrapped_trigger.should_initiate(state, dependencies, node_span_id)
+
+            # Fallback to the base implementation if no wrapped node
+            return super().should_initiate(state, dependencies, node_span_id)
+
+        @classmethod
+        def _queue_node_execution(
+            cls, state: StateType, dependencies: set[Type[BaseNode]], invoked_by: Optional[UUID] = None
+        ) -> UUID:
+            """
+            Delegates to the wrapped node's Trigger._queue_node_execution method to ensure
+            proper merge behavior (like AWAIT_ALL) is respected for dependency tracking.
+            """
+            # Get the wrapped node's Trigger class
+            wrapped_node = cls.node_class.__wrapped_node__
+            if wrapped_node is not None:
+                wrapped_trigger = wrapped_node.Trigger
+                # Delegate to the wrapped node's trigger logic for queuing
+                return wrapped_trigger._queue_node_execution(state, dependencies, invoked_by)
+
+            # Fallback to the base implementation if no wrapped node
+            return super()._queue_node_execution(state, dependencies, invoked_by)
+
     @classmethod
     def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:
         # Subclasses of BaseAdornableNode can override this method to provider their own

vellum/workflows/nodes/core/map_node/node.py

@@ -17,6 +17,7 @@ from typing import (
     overload,
 )
 
+from vellum.workflows.constants import undefined
 from vellum.workflows.context import ExecutionContext, execution_context, get_execution_context
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.errors.types import WorkflowErrorCode
@@ -218,6 +219,15 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
         #     value: List[str]
         outputs_class.__annotations__ = {**previous_annotations, reference.name: annotation}
 
+        # Create a NEW OutputReference with the List-wrapped type for discoverability during iteration
+        map_output_reference = OutputReference(
+            name=reference.name,
+            types=(annotation,),
+            instance=undefined,
+            outputs_class=outputs_class,
+        )
+        setattr(outputs_class, reference.name, map_output_reference)
+
         subworkflow_class = cls.subworkflow.instance if isinstance(cls.subworkflow, NodeReference) else None
         if subworkflow_class:
             output_id = subworkflow_class.__output_ids__.get(reference.name) or uuid4_from_hash(

vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py

@@ -1,6 +1,6 @@
 import pytest
 import json
-from typing import List, Union
+from typing import Any, Dict, List, Union
 
 from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.function_call import FunctionCall
@@ -32,6 +32,54 @@ def test_templating_node__dict_output():
     assert json.loads(dump) == {"key": "value"}
 
 
+def test_templating_node__dict_type_output():
+    """Tests that TemplatingNode correctly parses dict outputs when using dict type annotation."""
+
+    # GIVEN a templating node with dict output type that returns a dict
+    class DictTemplateNode(TemplatingNode[BaseState, dict]):
+        template = "{{ data }}"
+        inputs = {"data": {"key": "value"}}
+
+    # WHEN the node is run
+    node = DictTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected dict
+    assert outputs.result == {"key": "value"}
+
+
+def test_templating_node__any_type_output():
+    """Tests that TemplatingNode correctly parses dict outputs when using Any type annotation."""
+
+    # GIVEN a templating node with Any output type that returns a dict
+    class AnyTemplateNode(TemplatingNode[BaseState, Any]):
+        template = "{{ data }}"
+        inputs = {"data": {"key": "value"}}
+
+    # WHEN the node is run
+    node = AnyTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected dict
+    assert outputs.result == {"key": "value"}
+
+
+def test_templating_node__dict_str_any_type_output():
+    """Tests that TemplatingNode correctly parses dict outputs when using Dict[str, Any] type annotation."""
+
+    # GIVEN a templating node with Dict[str, Any] output type that returns a dict
+    class DictStrAnyTemplateNode(TemplatingNode[BaseState, Dict[str, Any]]):
+        template = "{{ data }}"
+        inputs = {"data": {"key": "value"}}
+
+    # WHEN the node is run
+    node = DictStrAnyTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected dict
+    assert outputs.result == {"key": "value"}
+
+
 def test_templating_node__int_output():
     # GIVEN a templating node that outputs an integer
     class IntTemplateNode(TemplatingNode[BaseState, int]):

vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -7,6 +7,7 @@ from vellum import (
     AdHocExpandMeta,
     ChatMessage,
     FunctionDefinition,
+    InitiatedAdHocExecutePromptEvent,
     PromptBlock,
     PromptOutput,
     PromptParameters,
@@ -185,7 +186,8 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                 expand_meta=self.expand_meta,
                 request_options=request_options,
             )
-            return iter([response])
+            initiated_event = InitiatedAdHocExecutePromptEvent(execution_id=response.execution_id)
+            return iter([initiated_event, response])
         else:
             return self._context.vellum_client.ad_hoc.adhoc_execute_prompt_stream(
                 ml_model=self.ml_model,

vellum/workflows/nodes/tests/test_utils.py

@@ -1,5 +1,5 @@
 import pytest
-from typing import Any, List, Union
+from typing import Any, Dict, List, Union
 
 from pydantic import BaseModel
 
@@ -34,6 +34,9 @@ class Person(BaseModel):
             Json,
             {"name": "test", "args": [1, 2]},
         ),
+        ('{"name": "Alice", "age": 30}', dict, {"name": "Alice", "age": 30}),
+        ('{"name": "Alice", "age": 30}', Dict[str, Any], {"name": "Alice", "age": 30}),
+        ('{"name": "Alice", "age": 30}', Any, {"name": "Alice", "age": 30}),
         ("42", Union[int, str], 42),
         ("hello", Union[int, str], "hello"),
     ],
@@ -47,6 +50,9 @@ class Person(BaseModel):
         "list_of_str",
         "simple_json",
         "function_call_json",
+        "dict_type",
+        "dict_str_any_type",
+        "any_type",
         "union_int",
         "union_str",
     ],

vellum/workflows/nodes/utils.py

@@ -141,7 +141,7 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
         else:
             return data
 
-    if output_type is Json:
+    if output_type is Json or output_type is Any or output_type is dict or get_origin(output_type) is dict:
         try:
             data = json.loads(result_as_str)
             # If we got a FunctionCallVellumValue, return just the value

vellum/workflows/references/__init__.py

@@ -4,6 +4,7 @@ from .lazy import LazyReference
 from .node import NodeReference
 from .output import OutputReference
 from .state_value import StateValueReference
+from .trigger import TriggerAttributeReference
 from .vellum_secret import VellumSecretReference
 from .workflow_input import WorkflowInputReference
 
@@ -14,6 +15,7 @@ __all__ = [
     "NodeReference",
     "OutputReference",
     "StateValueReference",
+    "TriggerAttributeReference",
     "VellumSecretReference",
     "WorkflowInputReference",
 ]

vellum/workflows/references/trigger.py

@@ -0,0 +1,83 @@
+"""Descriptor for referring to trigger attributes in workflow graphs."""
+
+from __future__ import annotations
+
+from uuid import UUID
+from typing import TYPE_CHECKING, Any, Generic, Optional, Tuple, Type, TypeVar, cast
+
+from pydantic import GetCoreSchemaHandler
+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
+
+if TYPE_CHECKING:
+    from vellum.workflows.state.base import BaseState
+    from vellum.workflows.triggers.base import BaseTrigger
+
+_T = TypeVar("_T")
+
+
+class TriggerAttributeReference(BaseDescriptor[_T], Generic[_T]):
+    """Reference to a trigger attribute defined via type annotations."""
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        types: Tuple[Type[_T], ...],
+        instance: Optional[_T],
+        trigger_class: Type[BaseTrigger],
+    ) -> None:
+        super().__init__(name=name, types=types, instance=instance)
+        self._trigger_class = trigger_class
+
+    @property
+    def trigger_class(self) -> Type[BaseTrigger]:
+        return self._trigger_class
+
+    @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__}."
+        )
+
+    def resolve(self, state: BaseState) -> _T:
+        trigger_attributes = getattr(state.meta, "trigger_attributes", {})
+        if self in trigger_attributes:
+            return cast(_T, trigger_attributes[self])
+
+        if state.meta.parent:
+            return self.resolve(state.meta.parent)
+
+        if type(None) in self.types:
+            return cast(_T, None)
+
+        raise NodeException(
+            message=f"Missing trigger attribute '{self.name}' for {self._trigger_class.__name__}",
+            code=WorkflowErrorCode.INVALID_INPUTS,
+        )
+
+    def __repr__(self) -> str:
+        return f"{self._trigger_class.__qualname__}.{self.name}"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, TriggerAttributeReference):
+            return False
+        return super().__eq__(other) and self._trigger_class == other._trigger_class
+
+    def __hash__(self) -> int:
+        return hash((self._trigger_class, self._name))
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Type[Any], handler: GetCoreSchemaHandler
+    ) -> core_schema.CoreSchema:
+        return core_schema.is_instance_schema(cls)

vellum/workflows/runner/runner.py

@@ -724,22 +724,24 @@ class WorkflowRunner(Generic[StateType]):
             parent_context: The parent context for the cancellation events
         """
         captured_stacktrace = "".join(traceback.format_stack())
-        for span_id, active_node in list(self._active_nodes_by_execution_id.items()):
-            rejection_event = NodeExecutionRejectedEvent(
-                trace_id=self._execution_context.trace_id,
-                span_id=span_id,
-                body=NodeExecutionRejectedBody(
-                    node_definition=active_node.node.__class__,
-                    error=WorkflowError(
-                        code=WorkflowErrorCode.NODE_CANCELLED,
-                        message=error_message,
+        active_span_ids = list(self._active_nodes_by_execution_id.keys())
+        for span_id in active_span_ids:
+            active_node = self._active_nodes_by_execution_id.pop(span_id, None)
+            if active_node is not None:
+                rejection_event = NodeExecutionRejectedEvent(
+                    trace_id=self._execution_context.trace_id,
+                    span_id=span_id,
+                    body=NodeExecutionRejectedBody(
+                        node_definition=active_node.node.__class__,
+                        error=WorkflowError(
+                            code=WorkflowErrorCode.NODE_CANCELLED,
+                            message=error_message,
+                        ),
+                        stacktrace=captured_stacktrace,
                     ),
-                    stacktrace=captured_stacktrace,
-                ),
-                parent=parent_context,
-            )
-            self._workflow_event_outer_queue.put(rejection_event)
-            self._active_nodes_by_execution_id.pop(span_id)
+                    parent=parent_context,
+                )
+                self._workflow_event_outer_queue.put(rejection_event)
 
     def _initiate_workflow_event(self) -> WorkflowExecutionInitiatedEvent:
         links: Optional[List[SpanLink]] = None

vellum/workflows/state/base.py

@@ -31,7 +31,12 @@ from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.utils.uuid import is_valid_uuid
 from vellum.workflows.constants import undefined
 from vellum.workflows.inputs.base import BaseInputs
-from vellum.workflows.references import ExternalInputReference, OutputReference, StateValueReference
+from vellum.workflows.references import (
+    ExternalInputReference,
+    OutputReference,
+    StateValueReference,
+    TriggerAttributeReference,
+)
 from vellum.workflows.state.delta import AppendStateDelta, SetStateDelta, StateDelta
 from vellum.workflows.types.definition import CodeResourceDefinition, serialize_type_encoder_with_id
 from vellum.workflows.types.generics import StateType, import_workflow_class, is_workflow_class
@@ -301,6 +306,7 @@ class StateMeta(UniversalBaseModel):
     workflow_inputs: BaseInputs = field(default_factory=BaseInputs)
     external_inputs: Dict[ExternalInputReference, Any] = field(default_factory=dict)
     node_outputs: Dict[OutputReference, Any] = field(default_factory=dict)
+    trigger_attributes: Dict[TriggerAttributeReference, Any] = field(default_factory=dict)
     node_execution_cache: NodeExecutionCache = field(default_factory=NodeExecutionCache)
     parent: Optional["BaseState"] = None
     __snapshot_callback__: Optional[Callable[[Optional[StateDelta]], None]] = field(init=False, default=None)
@@ -311,6 +317,7 @@ class StateMeta(UniversalBaseModel):
     def add_snapshot_callback(self, callback: Callable[[Optional[StateDelta]], None]) -> None:
         self.node_outputs = _make_snapshottable("meta.node_outputs", self.node_outputs, callback)
         self.external_inputs = _make_snapshottable("meta.external_inputs", self.external_inputs, callback)
+        self.trigger_attributes = _make_snapshottable("meta.trigger_attributes", self.trigger_attributes, callback)
         self.__snapshot_callback__ = callback
 
     def __setattr__(self, name: str, value: Any) -> None:
@@ -345,6 +352,12 @@ class StateMeta(UniversalBaseModel):
     def serialize_node_outputs(self, node_outputs: Dict[OutputReference, Any], _info: Any) -> Dict[str, Any]:
         return {str(descriptor.id): value for descriptor, value in node_outputs.items()}
 
+    @field_serializer("trigger_attributes")
+    def serialize_trigger_attributes(
+        self, trigger_attributes: Dict[TriggerAttributeReference, Any], _info: Any
+    ) -> Dict[str, Any]:
+        return {str(descriptor.id): value for descriptor, value in trigger_attributes.items()}
+
     @field_validator("node_outputs", mode="before")
     @classmethod
     def deserialize_node_outputs(cls, node_outputs: Any, info: ValidationInfo):
@@ -379,6 +392,41 @@ class StateMeta(UniversalBaseModel):
 
         return node_outputs
 
+    @field_validator("trigger_attributes", mode="before")
+    @classmethod
+    def deserialize_trigger_attributes(cls, trigger_attributes: Any, info: ValidationInfo):
+        if isinstance(trigger_attributes, dict):
+            workflow_definition = cls._get_workflow(info)
+            if not workflow_definition:
+                return trigger_attributes
+
+            trigger_attribute_map: Dict[Union[str, UUID], TriggerAttributeReference] = {}
+            for subgraph in workflow_definition.get_subgraphs():
+                for trigger_class in subgraph.triggers:
+                    for attribute in trigger_class:
+                        trigger_attribute_map[str(attribute)] = attribute
+                        attr_id = getattr(attribute, "id", None)
+                        if isinstance(attr_id, UUID):
+                            trigger_attribute_map[attr_id] = attribute
+                            trigger_attribute_map[str(attr_id)] = attribute
+
+            deserialized_attributes: Dict[TriggerAttributeReference, Any] = {}
+            for key, value in trigger_attributes.items():
+                reference: Optional[TriggerAttributeReference]
+                if is_valid_uuid(key):
+                    reference = trigger_attribute_map.get(UUID(key))
+                else:
+                    reference = trigger_attribute_map.get(key)
+
+                if not reference:
+                    continue
+
+                deserialized_attributes[reference] = value
+
+            return deserialized_attributes
+
+        return trigger_attributes
+
     @field_validator("node_execution_cache", mode="before")
     @classmethod
     def deserialize_node_execution_cache(cls, node_execution_cache: Any, info: ValidationInfo):

vellum/workflows/triggers/__init__.py

@@ -1,5 +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
 
-__all__ = ["BaseTrigger", "IntegrationTrigger", "ManualTrigger"]
+__all__ = ["BaseTrigger", "IntegrationTrigger", "ManualTrigger", "SlackTrigger"]