vellum-ai 1.7.7__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.7",
+            "User-Agent": "vellum-ai/1.7.8",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.7.7",
+            "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/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/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/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"]