vellum-ai 1.7.3__tar.gz → 1.7.5__tar.gz

{vellum_ai-1.7.3 → vellum_ai-1.7.5}/PKG-INFO

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

{vellum_ai-1.7.3 → vellum_ai-1.7.5}/ee/vellum_ee/assets/node-definitions.json

@@ -862,7 +862,7 @@
             "type": "CONSTANT_VALUE",
             "value": {
               "type": "NUMBER",
-              "value": 5.0
+              "value": 25.0
             }
           }
         },

{vellum_ai-1.7.3 → vellum_ai-1.7.5}/ee/vellum_ee/workflows/display/base.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass, field
+from enum import Enum
 from uuid import UUID
-from typing import Optional, Type
+from typing import TYPE_CHECKING, Dict, Optional, Type
 
 from pydantic import Field
 
@@ -9,6 +10,30 @@ from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.editor.types import NodeDisplayData
 
+if TYPE_CHECKING:
+    from vellum.workflows.triggers.base import BaseTrigger
+
+
+class WorkflowTriggerType(Enum):
+    MANUAL = "MANUAL"
+
+
+def get_trigger_type_mapping() -> Dict[Type["BaseTrigger"], WorkflowTriggerType]:
+    """
+    Get mapping from trigger classes to their WorkflowTriggerType enum values.
+
+    This is a function to avoid circular imports - it imports trigger classes
+    only when called, not at module load time.
+
+    Returns:
+        Dictionary mapping trigger classes to their enum types
+    """
+    from vellum.workflows.triggers.manual import ManualTrigger
+
+    return {
+        ManualTrigger: WorkflowTriggerType.MANUAL,
+    }
+
 
 class WorkflowDisplayDataViewport(UniversalBaseModel):
     x: float = 0.0

{vellum_ai-1.7.3 → vellum_ai-1.7.5}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py

@@ -435,7 +435,7 @@ def test_serialize_workflow():
             {
                 "id": "1668419e-a193-43a5-8a97-3394e89bf278",
                 "name": "max_prompt_iterations",
-                "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5.0}},
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 25.0}},
             },
             {
                 "id": "f92dc3ec-a19a-4491-a98a-2b2df322e2e3",

{vellum_ai-1.7.3 → vellum_ai-1.7.5}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py

@@ -204,7 +204,7 @@ def test_serialize_workflow():
             {
                 "id": "1668419e-a193-43a5-8a97-3394e89bf278",
                 "name": "max_prompt_iterations",
-                "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5.0}},
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 25.0}},
             },
             {
                 "id": "f92dc3ec-a19a-4491-a98a-2b2df322e2e3",

vellum_ai-1.7.5/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_manual_trigger_serialization.py

@@ -0,0 +1,113 @@
+"""Tests for serialization of workflows with ManualTrigger."""
+
+import pytest
+from typing import cast
+
+from deepdiff import DeepDiff
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.triggers.base import BaseTrigger
+from vellum.workflows.triggers.manual import ManualTrigger
+from vellum.workflows.types.core import JsonArray, JsonObject
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+class Inputs(BaseInputs):
+    input: str
+
+
+class SimpleNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        output = Inputs.input
+
+
+def create_workflow(trigger=None):
+    """Factory for creating test workflows."""
+
+    class TestWorkflow(BaseWorkflow[Inputs, BaseState]):
+        graph = trigger >> SimpleNode if trigger else SimpleNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            output = SimpleNode.Outputs.output
+
+    return TestWorkflow
+
+
+def serialize(workflow_class) -> JsonObject:
+    """Helper to serialize a workflow."""
+    return get_workflow_display(workflow_class=workflow_class).serialize()
+
+
+def test_manual_trigger_serialization():
+    """Workflow with ManualTrigger serializes with trigger field."""
+    result = serialize(create_workflow(ManualTrigger))
+    workflow_raw_data = cast(JsonObject, result["workflow_raw_data"])
+    trigger = cast(JsonObject, workflow_raw_data["trigger"])
+
+    assert trigger["type"] == "MANUAL"
+    assert not DeepDiff(
+        {
+            "type": "MANUAL",
+            "definition": {"name": "ManualTrigger", "module": ["vellum", "workflows", "triggers", "manual"]},
+        },
+        trigger,
+        ignore_order=True,
+    )
+
+
+def test_no_trigger_serialization():
+    """Workflow without trigger has no trigger field."""
+    result = serialize(create_workflow())
+    workflow_raw_data = cast(JsonObject, result["workflow_raw_data"])
+    assert "trigger" not in workflow_raw_data
+
+
+def test_manual_trigger_multiple_entrypoints():
+    """ManualTrigger with multiple entrypoints."""
+
+    class NodeA(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            output = Inputs.input
+
+    class NodeB(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            output = Inputs.input
+
+    class MultiWorkflow(BaseWorkflow[Inputs, BaseState]):
+        graph = ManualTrigger >> {NodeA, NodeB}
+
+        class Outputs(BaseWorkflow.Outputs):
+            output_a = NodeA.Outputs.output
+            output_b = NodeB.Outputs.output
+
+    result = serialize(MultiWorkflow)
+    workflow_data = cast(JsonObject, result["workflow_raw_data"])
+    trigger = cast(JsonObject, workflow_data["trigger"])
+    nodes = cast(JsonArray, workflow_data["nodes"])
+
+    assert trigger["type"] == "MANUAL"
+    assert len([n for n in nodes if cast(JsonObject, n)["type"] == "GENERIC"]) >= 2
+
+
+def test_serialized_workflow_structure():
+    """Verify complete structure of serialized workflow."""
+    result = serialize(create_workflow(ManualTrigger))
+    workflow_raw_data = cast(JsonObject, result["workflow_raw_data"])
+    definition = cast(JsonObject, workflow_raw_data["definition"])
+
+    assert result.keys() == {"workflow_raw_data", "input_variables", "state_variables", "output_variables"}
+    assert workflow_raw_data.keys() == {"nodes", "edges", "display_data", "definition", "output_values", "trigger"}
+    assert definition["name"] == "TestWorkflow"
+
+
+def test_unknown_trigger_type():
+    """Unknown trigger types raise ValueError."""
+
+    class UnknownTrigger(BaseTrigger):
+        pass
+
+    with pytest.raises(ValueError, match="Unknown trigger type: UnknownTrigger"):
+        serialize(create_workflow(UnknownTrigger))

{vellum_ai-1.7.3 → vellum_ai-1.7.5}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -37,6 +37,7 @@ from vellum_ee.workflows.display.base import (
     WorkflowInputsDisplay,
     WorkflowMetaDisplay,
     WorkflowOutputDisplay,
+    get_trigger_type_mapping,
 )
 from vellum_ee.workflows.display.editor.types import NodeDisplayData, NodeDisplayPosition
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
@@ -408,22 +409,74 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             except Exception as e:
                 self.display_context.add_error(e)
 
-        return {
-            "workflow_raw_data": {
-                "nodes": cast(JsonArray, nodes_dict_list),
-                "edges": edges,
-                "display_data": self.display_context.workflow_display.display_data.dict(),
-                "definition": {
-                    "name": self._workflow.__name__,
-                    "module": cast(JsonArray, self._workflow.__module__.split(".")),
-                },
-                "output_values": output_values,
+        # Serialize workflow-level trigger if present
+        trigger_data: Optional[JsonObject] = self._serialize_workflow_trigger()
+
+        workflow_raw_data: JsonObject = {
+            "nodes": cast(JsonArray, nodes_dict_list),
+            "edges": edges,
+            "display_data": self.display_context.workflow_display.display_data.dict(),
+            "definition": {
+                "name": self._workflow.__name__,
+                "module": cast(JsonArray, self._workflow.__module__.split(".")),
             },
+            "output_values": output_values,
+        }
+
+        if trigger_data is not None:
+            workflow_raw_data["trigger"] = trigger_data
+
+        return {
+            "workflow_raw_data": workflow_raw_data,
             "input_variables": input_variables,
             "state_variables": state_variables,
             "output_variables": output_variables,
         }
 
+    def _serialize_workflow_trigger(self) -> Optional[JsonObject]:
+        """
+        Serialize workflow-level trigger information.
+
+        Returns:
+            JsonObject with trigger data if a trigger is present, None otherwise
+        """
+        # Get all trigger edges from the workflow's subgraphs
+        trigger_edges = []
+        for subgraph in self._workflow.get_subgraphs():
+            trigger_edges.extend(list(subgraph.trigger_edges))
+
+        if not trigger_edges:
+            # No workflow-level trigger defined
+            return None
+
+        # Get the trigger class from the first edge
+        trigger_class = trigger_edges[0].trigger_class
+
+        # Validate that all trigger edges use the same trigger type
+        trigger_type_mapping = get_trigger_type_mapping()
+        for edge in trigger_edges:
+            if edge.trigger_class != trigger_class:
+                raise ValueError(
+                    f"Mixed trigger types not supported. Found {trigger_class.__name__} and "
+                    f"{edge.trigger_class.__name__} in the same workflow."
+                )
+
+        # Get the trigger type from the mapping
+        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()."
+            )
+
+        return {
+            "type": trigger_type.value,
+            "definition": {
+                "name": trigger_class.__name__,
+                "module": cast(JsonArray, trigger_class.__module__.split(".")),
+            },
+        }
+
     def _serialize_edge_display_data(self, edge_display: EdgeDisplay) -> Optional[JsonObject]:
         """Serialize edge display data, returning None if no display data is present."""
         if edge_display.z_index is not None:

{vellum_ai-1.7.3 → vellum_ai-1.7.5}/pyproject.toml

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

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

{vellum_ai-1.7.3 → vellum_ai-1.7.5}/src/vellum/client/core/pydantic_utilities.py

@@ -158,7 +158,14 @@ class UniversalBaseModel(pydantic.BaseModel):
 
             dict_dump = super().dict(**kwargs_with_defaults_exclude_unset_include_fields)
 
-        return convert_and_respect_annotation_metadata(object_=dict_dump, annotation=self.__class__, direction="write")
+        # Skip expensive annotation metadata conversion for types that don't require it.
+        # This optimization dramatically improves serialization performance for large nested
+        # structures by avoiding repeated typing.get_origin checks on every element.
+        if self.__class__.__name__ in annotated_types:
+            return convert_and_respect_annotation_metadata(
+                object_=dict_dump, annotation=self.__class__, direction="write"
+            )
+        return dict_dump
 
 
 def _union_list_of_pydantic_dicts(source: List[Any], destination: List[Any]) -> List[Any]:

{vellum_ai-1.7.3 → vellum_ai-1.7.5}/src/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_ai-1.7.3 → vellum_ai-1.7.5}/src/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: