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

vellum/__init__.py

@@ -353,6 +353,7 @@ from .client.types import (
     PaginatedSlimWorkflowDeploymentList,
     PaginatedTestSuiteRunExecutionList,
     PaginatedTestSuiteTestCaseList,
+    PaginatedWorkflowDeploymentReleaseList,
     PaginatedWorkflowReleaseTagReadList,
     PaginatedWorkflowSandboxExampleList,
     ParentContext,
@@ -1099,6 +1100,7 @@ __all__ = [
     "PaginatedSlimWorkflowDeploymentList",
     "PaginatedTestSuiteRunExecutionList",
     "PaginatedTestSuiteTestCaseList",
+    "PaginatedWorkflowDeploymentReleaseList",
     "PaginatedWorkflowReleaseTagReadList",
     "PaginatedWorkflowSandboxExampleList",
     "ParentContext",

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

vellum/client/reference.md

@@ -6746,6 +6746,101 @@ client.workflow_deployments.update_workflow_release_tag(
 </dl>
 
 
+</dd>
+</dl>
+</details>
+
+<details><summary><code>client.workflow_deployments.<a href="src/vellum/resources/workflow_deployments/client.py">list_workflow_deployment_releases</a>(...)</code></summary>
+<dl>
+<dd>
+
+#### 📝 Description
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+List the Releases of the specified Workflow Deployment for the current Environment.
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### 🔌 Usage
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+```python
+from vellum import Vellum
+
+client = Vellum(
+    api_version="YOUR_API_VERSION",
+    api_key="YOUR_API_KEY",
+)
+client.workflow_deployments.list_workflow_deployment_releases(
+    id="id",
+)
+
+```
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### ⚙️ Parameters
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+**id:** `str` — Either the Workflow Deployment's ID or its unique name
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**limit:** `typing.Optional[int]` — Number of results to return per page.
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**offset:** `typing.Optional[int]` — The initial index from which to return the results.
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**ordering:** `typing.Optional[str]` — Which field to use when ordering the results.
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration.
+    
+</dd>
+</dl>
+</dd>
+</dl>
+
+
 </dd>
 </dl>
 </details>

vellum/client/resources/workflow_deployments/client.py

@@ -5,6 +5,7 @@ import typing
 from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from ...core.request_options import RequestOptions
 from ...types.paginated_slim_workflow_deployment_list import PaginatedSlimWorkflowDeploymentList
+from ...types.paginated_workflow_deployment_release_list import PaginatedWorkflowDeploymentReleaseList
 from ...types.paginated_workflow_release_tag_read_list import PaginatedWorkflowReleaseTagReadList
 from ...types.workflow_deployment_event_executions_response import WorkflowDeploymentEventExecutionsResponse
 from ...types.workflow_deployment_history_item import WorkflowDeploymentHistoryItem
@@ -387,6 +388,57 @@ class WorkflowDeploymentsClient:
         )
         return _response.data
 
+    def list_workflow_deployment_releases(
+        self,
+        id: str,
+        *,
+        limit: typing.Optional[int] = None,
+        offset: typing.Optional[int] = None,
+        ordering: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> PaginatedWorkflowDeploymentReleaseList:
+        """
+        List the Releases of the specified Workflow Deployment for the current Environment.
+
+        Parameters
+        ----------
+        id : str
+            Either the Workflow Deployment's ID or its unique name
+
+        limit : typing.Optional[int]
+            Number of results to return per page.
+
+        offset : typing.Optional[int]
+            The initial index from which to return the results.
+
+        ordering : typing.Optional[str]
+            Which field to use when ordering the results.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        PaginatedWorkflowDeploymentReleaseList
+
+
+        Examples
+        --------
+        from vellum import Vellum
+
+        client = Vellum(
+            api_version="YOUR_API_VERSION",
+            api_key="YOUR_API_KEY",
+        )
+        client.workflow_deployments.list_workflow_deployment_releases(
+            id="id",
+        )
+        """
+        _response = self._raw_client.list_workflow_deployment_releases(
+            id, limit=limit, offset=offset, ordering=ordering, request_options=request_options
+        )
+        return _response.data
+
     def retrieve_workflow_deployment_release(
         self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
     ) -> WorkflowDeploymentRelease:
@@ -857,6 +909,65 @@ class AsyncWorkflowDeploymentsClient:
         )
         return _response.data
 
+    async def list_workflow_deployment_releases(
+        self,
+        id: str,
+        *,
+        limit: typing.Optional[int] = None,
+        offset: typing.Optional[int] = None,
+        ordering: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> PaginatedWorkflowDeploymentReleaseList:
+        """
+        List the Releases of the specified Workflow Deployment for the current Environment.
+
+        Parameters
+        ----------
+        id : str
+            Either the Workflow Deployment's ID or its unique name
+
+        limit : typing.Optional[int]
+            Number of results to return per page.
+
+        offset : typing.Optional[int]
+            The initial index from which to return the results.
+
+        ordering : typing.Optional[str]
+            Which field to use when ordering the results.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        PaginatedWorkflowDeploymentReleaseList
+
+
+        Examples
+        --------
+        import asyncio
+
+        from vellum import AsyncVellum
+
+        client = AsyncVellum(
+            api_version="YOUR_API_VERSION",
+            api_key="YOUR_API_KEY",
+        )
+
+
+        async def main() -> None:
+            await client.workflow_deployments.list_workflow_deployment_releases(
+                id="id",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._raw_client.list_workflow_deployment_releases(
+            id, limit=limit, offset=offset, ordering=ordering, request_options=request_options
+        )
+        return _response.data
+
     async def retrieve_workflow_deployment_release(
         self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
     ) -> WorkflowDeploymentRelease:

vellum/client/resources/workflow_deployments/raw_client.py

@@ -10,6 +10,7 @@ from ...core.jsonable_encoder import jsonable_encoder
 from ...core.pydantic_utilities import parse_obj_as
 from ...core.request_options import RequestOptions
 from ...types.paginated_slim_workflow_deployment_list import PaginatedSlimWorkflowDeploymentList
+from ...types.paginated_workflow_deployment_release_list import PaginatedWorkflowDeploymentReleaseList
 from ...types.paginated_workflow_release_tag_read_list import PaginatedWorkflowReleaseTagReadList
 from ...types.workflow_deployment_event_executions_response import WorkflowDeploymentEventExecutionsResponse
 from ...types.workflow_deployment_history_item import WorkflowDeploymentHistoryItem
@@ -437,6 +438,66 @@ class RawWorkflowDeploymentsClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
+    def list_workflow_deployment_releases(
+        self,
+        id: str,
+        *,
+        limit: typing.Optional[int] = None,
+        offset: typing.Optional[int] = None,
+        ordering: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[PaginatedWorkflowDeploymentReleaseList]:
+        """
+        List the Releases of the specified Workflow Deployment for the current Environment.
+
+        Parameters
+        ----------
+        id : str
+            Either the Workflow Deployment's ID or its unique name
+
+        limit : typing.Optional[int]
+            Number of results to return per page.
+
+        offset : typing.Optional[int]
+            The initial index from which to return the results.
+
+        ordering : typing.Optional[str]
+            Which field to use when ordering the results.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[PaginatedWorkflowDeploymentReleaseList]
+
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            f"v1/workflow-deployments/{jsonable_encoder(id)}/releases",
+            base_url=self._client_wrapper.get_environment().default,
+            method="GET",
+            params={
+                "limit": limit,
+                "offset": offset,
+                "ordering": ordering,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    PaginatedWorkflowDeploymentReleaseList,
+                    parse_obj_as(
+                        type_=PaginatedWorkflowDeploymentReleaseList,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
     def retrieve_workflow_deployment_release(
         self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
     ) -> HttpResponse[WorkflowDeploymentRelease]:
@@ -894,6 +955,66 @@ class AsyncRawWorkflowDeploymentsClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
+    async def list_workflow_deployment_releases(
+        self,
+        id: str,
+        *,
+        limit: typing.Optional[int] = None,
+        offset: typing.Optional[int] = None,
+        ordering: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[PaginatedWorkflowDeploymentReleaseList]:
+        """
+        List the Releases of the specified Workflow Deployment for the current Environment.
+
+        Parameters
+        ----------
+        id : str
+            Either the Workflow Deployment's ID or its unique name
+
+        limit : typing.Optional[int]
+            Number of results to return per page.
+
+        offset : typing.Optional[int]
+            The initial index from which to return the results.
+
+        ordering : typing.Optional[str]
+            Which field to use when ordering the results.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[PaginatedWorkflowDeploymentReleaseList]
+
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            f"v1/workflow-deployments/{jsonable_encoder(id)}/releases",
+            base_url=self._client_wrapper.get_environment().default,
+            method="GET",
+            params={
+                "limit": limit,
+                "offset": offset,
+                "ordering": ordering,
+            },
+            request_options=request_options,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    PaginatedWorkflowDeploymentReleaseList,
+                    parse_obj_as(
+                        type_=PaginatedWorkflowDeploymentReleaseList,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
     async def retrieve_workflow_deployment_release(
         self, id: str, release_id_or_release_tag: str, *, request_options: typing.Optional[RequestOptions] = None
     ) -> AsyncHttpResponse[WorkflowDeploymentRelease]:

vellum/client/types/__init__.py

@@ -361,6 +361,7 @@ from .paginated_slim_tool_definition_list import PaginatedSlimToolDefinitionList
 from .paginated_slim_workflow_deployment_list import PaginatedSlimWorkflowDeploymentList
 from .paginated_test_suite_run_execution_list import PaginatedTestSuiteRunExecutionList
 from .paginated_test_suite_test_case_list import PaginatedTestSuiteTestCaseList
+from .paginated_workflow_deployment_release_list import PaginatedWorkflowDeploymentReleaseList
 from .paginated_workflow_release_tag_read_list import PaginatedWorkflowReleaseTagReadList
 from .paginated_workflow_sandbox_example_list import PaginatedWorkflowSandboxExampleList
 from .parent_context import ParentContext
@@ -1068,6 +1069,7 @@ __all__ = [
     "PaginatedSlimWorkflowDeploymentList",
     "PaginatedTestSuiteRunExecutionList",
     "PaginatedTestSuiteTestCaseList",
+    "PaginatedWorkflowDeploymentReleaseList",
     "PaginatedWorkflowReleaseTagReadList",
     "PaginatedWorkflowSandboxExampleList",
     "ParentContext",

vellum/client/types/paginated_workflow_deployment_release_list.py

@@ -0,0 +1,30 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from __future__ import annotations
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel, update_forward_refs
+from .workflow_deployment_release import WorkflowDeploymentRelease
+
+
+class PaginatedWorkflowDeploymentReleaseList(UniversalBaseModel):
+    count: typing.Optional[int] = None
+    next: typing.Optional[str] = None
+    previous: typing.Optional[str] = None
+    results: typing.Optional[typing.List[WorkflowDeploymentRelease]] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow
+
+
+from .array_vellum_value import ArrayVellumValue  # noqa: E402, F401, I001
+
+update_forward_refs(PaginatedWorkflowDeploymentReleaseList)

vellum/client/types/vellum_error_code_enum.py

@@ -8,10 +8,12 @@ VellumErrorCodeEnum = typing.Union[
         "INVALID_INPUTS",
         "PROVIDER_ERROR",
         "PROVIDER_CREDENTIALS_UNAVAILABLE",
+        "INTEGRATION_CREDENTIALS_UNAVAILABLE",
         "REQUEST_TIMEOUT",
         "INTERNAL_SERVER_ERROR",
         "USER_DEFINED_ERROR",
         "WORKFLOW_CANCELLED",
+        "NODE_CANCELLED",
     ],
     typing.Any,
 ]

vellum/client/types/vellum_sdk_error_code_enum.py

@@ -12,9 +12,11 @@ VellumSdkErrorCodeEnum = typing.Union[
         "INVALID_TEMPLATE",
         "INTERNAL_ERROR",
         "PROVIDER_CREDENTIALS_UNAVAILABLE",
+        "INTEGRATION_CREDENTIALS_UNAVAILABLE",
         "PROVIDER_ERROR",
         "USER_DEFINED_ERROR",
         "WORKFLOW_CANCELLED",
+        "NODE_CANCELLED",
         "NODE_EXECUTION",
     ],
     typing.Any,

vellum/client/types/workflow_execution_event_error_code.py

@@ -7,9 +7,11 @@ WorkflowExecutionEventErrorCode = typing.Union[
         "WORKFLOW_INITIALIZATION",
         "WORKFLOW_CANCELLED",
         "PROVIDER_CREDENTIALS_UNAVAILABLE",
+        "INTEGRATION_CREDENTIALS_UNAVAILABLE",
         "NODE_EXECUTION_COUNT_LIMIT_REACHED",
         "INTERNAL_SERVER_ERROR",
         "NODE_EXECUTION",
+        "NODE_CANCELLED",
         "LLM_PROVIDER",
         "INVALID_TEMPLATE",
         "INVALID_INPUTS",

vellum/types/paginated_workflow_deployment_release_list.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.paginated_workflow_deployment_release_list import *

vellum/workflows/edges/__init__.py

@@ -1,5 +1,7 @@
 from .edge import Edge
+from .trigger_edge import TriggerEdge
 
 __all__ = [
     "Edge",
+    "TriggerEdge",
 ]

vellum/workflows/edges/trigger_edge.py

@@ -0,0 +1,67 @@
+from typing import TYPE_CHECKING, Any, Type
+
+if TYPE_CHECKING:
+    from vellum.workflows.nodes.bases import BaseNode
+    from vellum.workflows.triggers.base import BaseTrigger
+
+
+class TriggerEdge:
+    """
+    Represents an edge from a Trigger to a Node in the workflow graph.
+
+    TriggerEdge is analogous to Edge, but connects triggers to nodes instead of
+    nodes to nodes. These edges define which nodes should be executed when a
+    particular trigger fires.
+
+    Examples:
+        ManualTrigger >> MyNode  # Creates TriggerEdge(ManualTrigger, MyNode)
+        SlackTrigger >> ProcessNode  # Creates TriggerEdge(SlackTrigger, ProcessNode)
+
+    Attributes:
+        trigger_class: The trigger class that initiates execution
+        to_node: The node that should execute when the trigger fires
+    """
+
+    def __init__(self, trigger_class: Type["BaseTrigger"], to_node: Type["BaseNode"]):
+        """
+        Initialize a TriggerEdge.
+
+        Args:
+            trigger_class: The trigger class that initiates execution
+            to_node: The node class that should execute when triggered
+        """
+        self.trigger_class = trigger_class
+        self.to_node = to_node
+
+    def __eq__(self, other: Any) -> bool:
+        """
+        Two TriggerEdges are equal if they have the same trigger and target node.
+
+        Args:
+            other: Another object to compare with
+
+        Returns:
+            True if both edges connect the same trigger to the same node
+        """
+        if not isinstance(other, TriggerEdge):
+            return False
+
+        return self.trigger_class == other.trigger_class and self.to_node == other.to_node
+
+    def __hash__(self) -> int:
+        """
+        Hash based on trigger and target node for set/dict operations.
+
+        Returns:
+            Hash value for this edge
+        """
+        return hash((self.trigger_class, self.to_node))
+
+    def __repr__(self) -> str:
+        """
+        String representation showing the trigger-to-node connection.
+
+        Returns:
+            String in format "TriggerName >> NodeName"
+        """
+        return f"{self.trigger_class.__name__} >> {self.to_node.__name__}"

vellum/workflows/events/tests/test_event.py

@@ -227,6 +227,45 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     "outputs": {
                         "example": "foo",
                     },
+                    "final_state": None,
+                },
+                "parent": None,
+                "links": None,
+            },
+        ),
+        (
+            WorkflowExecutionFulfilledEvent(
+                id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                timestamp=datetime(2024, 1, 1, 12, 0, 0, tzinfo=timezone.utc),
+                trace_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                body=WorkflowExecutionFulfilledBody(
+                    workflow_definition=MockWorkflow,
+                    outputs=MockNode.Outputs(
+                        example="foo",
+                    ),
+                    final_state=BaseState(writable_value=42),
+                ),
+            ),
+            {
+                "id": "123e4567-e89b-12d3-a456-426614174000",
+                "api_version": "2024-10-25",
+                "timestamp": "2024-01-01T12:00:00Z",
+                "trace_id": "123e4567-e89b-12d3-a456-426614174000",
+                "span_id": "123e4567-e89b-12d3-a456-426614174000",
+                "name": "workflow.execution.fulfilled",
+                "body": {
+                    "workflow_definition": {
+                        "id": mock_workflow_uuid,
+                        "name": "MockWorkflow",
+                        "module": module_root + ["events", "tests", "test_event"],
+                    },
+                    "outputs": {
+                        "example": "foo",
+                    },
+                    "final_state": {
+                        "writable_value": 42,
+                    },
                 },
                 "parent": None,
                 "links": None,
@@ -427,6 +466,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
         "node.execution.initiated",
         "workflow.execution.streaming",
         "workflow.execution.fulfilled",
+        "workflow.execution.fulfilled_with_state",
         "workflow.execution.rejected",
         "node.execution.streaming",
         "node.execution.fulfilled",

vellum/workflows/events/workflow.py

@@ -137,22 +137,34 @@ class WorkflowExecutionStreamingEvent(_BaseWorkflowEvent):
         return self.body.output
 
 
-class WorkflowExecutionFulfilledBody(_BaseWorkflowExecutionBody, Generic[OutputsType]):
+class WorkflowExecutionFulfilledBody(_BaseWorkflowExecutionBody, Generic[OutputsType, StateType]):
     outputs: OutputsType
+    final_state: Optional[StateType] = None
 
     @field_serializer("outputs")
     def serialize_outputs(self, outputs: OutputsType, _info: Any) -> Dict[str, Any]:
         return default_serializer(outputs)
 
+    @field_serializer("final_state")
+    def serialize_final_state(self, final_state: Optional[StateType], _info: Any) -> Optional[Dict[str, Any]]:
+        if final_state is None:
+            return None
+        state_dict = {k: v for k, v in final_state if k != "meta"}
+        return default_serializer(state_dict)
 
-class WorkflowExecutionFulfilledEvent(_BaseWorkflowEvent, Generic[OutputsType]):
+
+class WorkflowExecutionFulfilledEvent(_BaseWorkflowEvent, Generic[OutputsType, StateType]):
     name: Literal["workflow.execution.fulfilled"] = "workflow.execution.fulfilled"
-    body: WorkflowExecutionFulfilledBody[OutputsType]
+    body: WorkflowExecutionFulfilledBody[OutputsType, StateType]
 
     @property
     def outputs(self) -> OutputsType:
         return self.body.outputs
 
+    @property
+    def final_state(self) -> Optional[StateType]:
+        return self.body.final_state
+
 
 class WorkflowExecutionRejectedBody(_BaseWorkflowExecutionBody):
     error: WorkflowError