vellum-ai 1.8.5__tar.gz → 1.9.0__tar.gz

{vellum_ai-1.8.5 → vellum_ai-1.9.0}/PKG-INFO

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

vellum_ai-1.8.5/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_vellum_integration_trigger_serialization.py → vellum_ai-1.9.0/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_integration_trigger_serialization.py

@@ -1,18 +1,18 @@
-"""Tests for VellumIntegrationTrigger serialization."""
+"""Tests for IntegrationTrigger serialization."""
 
 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.vellum_integration import VellumIntegrationTrigger
+from vellum.workflows.triggers.integration import IntegrationTrigger
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 
 def test_vellum_integration_trigger_serialization():
-    """VellumIntegrationTrigger subclass serializes with class name and module path."""
+    """IntegrationTrigger subclass serializes with class name and module path."""
 
-    # Create a custom VellumIntegrationTrigger subclass
-    class SlackMessageTrigger(VellumIntegrationTrigger):
+    # Create a custom IntegrationTrigger subclass
+    class SlackMessageTrigger(IntegrationTrigger):
         """Custom Slack message trigger."""
 
         message: str
@@ -71,7 +71,7 @@ def test_vellum_integration_trigger_serialization():
 def test_vellum_integration_trigger_id_consistency():
     """Validates trigger and attribute IDs match between definitions and references."""
 
-    class SlackMessageTrigger(VellumIntegrationTrigger):
+    class SlackMessageTrigger(IntegrationTrigger):
         message: str
         channel: str
 
@@ -147,7 +147,7 @@ def test_vellum_integration_trigger_id_consistency():
 def test_trigger_module_paths_are_canonical():
     """Validates trigger module_path and class_name for consistent codegen."""
 
-    class TestSlackTrigger(VellumIntegrationTrigger):
+    class TestSlackTrigger(IntegrationTrigger):
         message: str
 
         class Config:
@@ -184,7 +184,7 @@ def test_trigger_module_paths_are_canonical():
 def test_integration_trigger_no_entrypoint_node():
     """IntegrationTrigger-only workflows use trigger ID in edges."""
 
-    class SlackMessageTrigger(VellumIntegrationTrigger):
+    class SlackMessageTrigger(IntegrationTrigger):
         message: str
 
         class Config:

{vellum_ai-1.8.5 → vellum_ai-1.9.0}/ee/vellum_ee/workflows/display/utils/expressions.py

@@ -57,7 +57,7 @@ from vellum.workflows.references.workflow_input import WorkflowInputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum.workflows.types.generics import is_workflow_class
 from vellum.workflows.utils.functions import compile_function_definition
-from vellum.workflows.utils.uuids import get_trigger_id, uuid4_from_hash
+from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.utils.exceptions import InvalidInputReferenceError, UnsupportedSerializationException
 from vellum_ee.workflows.server.virtual_file_loader import VirtualFileLoader
 
@@ -353,9 +353,8 @@ def serialize_value(executable_id: UUID, display_context: "WorkflowDisplayContex
         }
 
     if isinstance(value, TriggerAttributeReference):
-        # Generate trigger ID using get_trigger_id to ensure consistency with trigger definitions
         trigger_class = value.trigger_class
-        trigger_id = get_trigger_id(trigger_class)
+        trigger_id = trigger_class.__id__
 
         return {
             "type": "TRIGGER_ATTRIBUTE",

{vellum_ai-1.8.5 → vellum_ai-1.9.0}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -25,12 +25,12 @@ 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.integration import IntegrationTrigger
 from vellum.workflows.triggers.manual import ManualTrigger
-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 get_trigger_id, uuid4_from_hash
+from vellum.workflows.utils.uuids import 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 (
@@ -190,7 +190,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
         # For IntegrationTrigger only: no ENTRYPOINT node (use trigger ID directly in edges)
         manual_trigger_edges = [edge for edge in trigger_edges if issubclass(edge.trigger_class, ManualTrigger)]
         integration_trigger_edges = [
-            edge for edge in trigger_edges if issubclass(edge.trigger_class, VellumIntegrationTrigger)
+            edge for edge in trigger_edges if issubclass(edge.trigger_class, IntegrationTrigger)
         ]
 
         has_manual_trigger = len(manual_trigger_edges) > 0
@@ -202,7 +202,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
         if has_manual_trigger:
             # ManualTrigger: use trigger ID for ENTRYPOINT node (backward compatibility)
             trigger_class = manual_trigger_edges[0].trigger_class
-            entrypoint_node_id = get_trigger_id(trigger_class)
+            entrypoint_node_id = trigger_class.__id__
             entrypoint_node_source_handle_id = self.display_context.workflow_display.entrypoint_node_source_handle_id
 
             # Add ENTRYPOINT node for ManualTrigger workflows
@@ -386,7 +386,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
         if has_only_integration_trigger:
             # Use trigger ID directly as sourceNodeId (no ENTRYPOINT node)
             trigger_class = integration_trigger_edges[0].trigger_class
-            trigger_id = get_trigger_id(trigger_class)
+            trigger_id = trigger_class.__id__
             trigger_source_handle_id = trigger_id  # Use trigger ID as handle ID
 
             for target_node, entrypoint_display in self.display_context.entrypoint_displays.items():
@@ -536,12 +536,12 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                     f"{edge.trigger_class.__name__} in the same workflow."
                 )
 
-        # Get the trigger type from the mapping, or check if it's a VellumIntegrationTrigger subclass
+        # Get the trigger type from the mapping, or check if it's an IntegrationTrigger subclass
         trigger_type = trigger_type_mapping.get(trigger_class)
         if trigger_type is None:
-            # Check if it's a VellumIntegrationTrigger subclass
+            # Check if it's an IntegrationTrigger subclass
 
-            if issubclass(trigger_class, VellumIntegrationTrigger):
+            if issubclass(trigger_class, IntegrationTrigger):
                 trigger_type = WorkflowTriggerType.INTEGRATION
             else:
                 raise ValueError(
@@ -550,7 +550,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                 )
 
         # Return as a list with a single trigger object matching Django schema
-        trigger_id = get_trigger_id(trigger_class)
+        trigger_id = trigger_class.__id__
 
         # Serialize trigger attributes like node outputs
         attribute_references = trigger_class.attribute_references().values()

{vellum_ai-1.8.5 → vellum_ai-1.9.0}/ee/vellum_ee/workflows/server/virtual_file_loader.py

@@ -30,7 +30,11 @@ class VirtualFileLoader(importlib.abc.Loader):
 
         if module_info:
             file_path, code = module_info
-            compiled = compile(code, file_path, "exec")
+            namespaced_path = (
+                file_path if file_path.startswith(f"{self.namespace}/") else f"{self.namespace}/{file_path}"
+            )
+            module.__file__ = namespaced_path
+            compiled = compile(code, namespaced_path, "exec")
             exec(compiled, module.__dict__)
 
     def get_source(self, fullname):
@@ -58,6 +62,18 @@ class VirtualFileLoader(importlib.abc.Loader):
             if code is not None:
                 return file_path, code
 
+            relative_name = self._to_relative(fullname)
+            if relative_name is not None and self._is_package_directory(relative_name):
+                return self._generate_init_content(relative_name)
+
+        return None
+
+    def _to_relative(self, fullname: str) -> Optional[str]:
+        """Convert a fully qualified module name to a relative name without the namespace prefix."""
+        if fullname.startswith(self.namespace + "."):
+            return fullname[len(self.namespace) + 1 :]
+        elif fullname == self.namespace:
+            return ""
         return None
 
     def _get_file_path(self, fullname):
@@ -67,6 +83,62 @@ class VirtualFileLoader(importlib.abc.Loader):
         file_key_name = re.sub(r"^" + re.escape(self.namespace) + r"/", "", file_path)
         return self.files.get(file_key_name)
 
+    def _is_package_directory(self, fullname: str) -> bool:
+        """Check if directory contains .py files that should be treated as a package."""
+        if fullname == "":
+            # This is the root namespace, so it's a package directory
+            return True
+
+        directory_prefix = fullname.replace(".", "/") + "/"
+        for file_path in self.files.keys():
+            if file_path.startswith(directory_prefix):
+                if file_path.endswith(".py") and not file_path.endswith("__init__.py"):
+                    return True
+                remaining_path = file_path[len(directory_prefix) :]
+                if "/" in remaining_path:
+                    return True
+
+        return False
+
+    def _generate_init_content(self, fullname: str) -> tuple[str, str]:
+        """Auto-generate empty __init__.py content to mark directory as a package."""
+        if fullname == "":
+            if any(file_path.startswith("display/") for file_path in self.files.keys()):
+                return (
+                    "__init__.py",
+                    """\
+from .display import *
+""",
+                )
+            else:
+                return "__init__.py", ""
+
+        directory_prefix = fullname.replace(".", "/") + "/"
+        file_path = directory_prefix + "__init__.py"
+
+        if not fullname.startswith("display"):
+            return "__init__.py", ""
+
+        # We have to go through the effort of exhaustively importing all display modules, because that's how
+        # dynamically annotate our Workflow graph.
+        all_nested_files = [
+            file_path[len(directory_prefix) :]
+            for file_path in self.files.keys()
+            if file_path.startswith(directory_prefix)
+        ]
+
+        top_level_items = {file_path.split("/")[0] for file_path in all_nested_files}
+
+        top_level_modules = [
+            re.sub(r"\.py$", "", file_path)
+            for file_path in top_level_items
+            if file_path.endswith(".py") or "." not in file_path
+        ]
+
+        code = "\n".join([f"from .{file_path} import *" for file_path in top_level_modules])
+
+        return file_path, code
+
 
 class VirtualFileFinder(BaseWorkflowFinder):
     def __init__(self, files: dict[str, str], namespace: str, source_module: Optional[str] = None):
@@ -82,7 +154,7 @@ class VirtualFileFinder(BaseWorkflowFinder):
 
     def find_spec(self, fullname: str, path, target=None):
         module_info = self.loader._resolve_module(fullname)
-        if module_info:
+        if isinstance(module_info, tuple) and len(module_info) == 2:
             file_path, _ = module_info
             is_package = file_path.endswith("__init__.py")
             return importlib.machinery.ModuleSpec(

{vellum_ai-1.8.5 → vellum_ai-1.9.0}/ee/vellum_ee/workflows/tests/test_server.py

@@ -1,17 +1,19 @@
 import pytest
 import sys
-from uuid import uuid4
+from uuid import UUID, uuid4
 from typing import Type, cast
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.code_executor_response import CodeExecutorResponse
 from vellum.client.types.number_vellum_value import NumberVellumValue
 from vellum.workflows import BaseWorkflow
+from vellum.workflows.events.workflow import WorkflowExecutionInitiatedBody
 from vellum.workflows.exceptions import WorkflowInitializationException
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.utils.uuids import generate_workflow_deployment_prefix
 from vellum.workflows.utils.zip import zip_file_map
+from vellum_ee.workflows.display.utils.events import event_enricher
 from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 from vellum_ee.workflows.server.virtual_file_loader import VirtualFileFinder
 
@@ -27,20 +29,12 @@ def test_load_workflow_event_display_context():
 def test_load_from_module__lazy_reference_in_file_loader():
     # GIVEN a workflow module with a node containing a lazy reference
     files = {
-        "__init__.py": "",
         "workflow.py": """\
 from vellum.workflows import BaseWorkflow
 from .nodes.start_node import StartNode
 
 class Workflow(BaseWorkflow):
     graph = StartNode
-""",
-        "nodes/__init__.py": """\
-from .start_node import StartNode
-
-__all__ = [
-    "StartNode",
-]
 """,
         "nodes/start_node.py": """\
 from vellum.workflows.nodes import BaseNode
@@ -98,11 +92,6 @@ class Workflow(BaseWorkflow):
 
     class Outputs(BaseWorkflow.Outputs):
        final_output = CodeExecutionNode.Outputs.result
-""",
-        "nodes/__init__.py": """
-from .code_execution_node import CodeExecutionNode
-
-__all__ = ["CodeExecutionNode"]
 """,
         "nodes/code_execution_node/__init__.py": """
 from typing import Any
@@ -174,11 +163,6 @@ class Workflow(BaseWorkflow):
 
     class Outputs(BaseWorkflow.Outputs):
        final_output = CodeExecutionNode.Outputs.result
-""",
-        "nodes/__init__.py": """
-from .code_execution_node import CodeExecutionNode
-
-__all__ = ["CodeExecutionNode"]
 """,
         "nodes/code_execution_node/__init__.py": """
 from typing import Union
@@ -250,11 +234,6 @@ class Workflow(BaseWorkflow):
 
     class Outputs(BaseWorkflow.Outputs):
        final_output = CodeExecutionNode.Outputs.result
-""",
-        "nodes/__init__.py": """
-from .code_execution_node import CodeExecutionNode
-
-__all__ = ["CodeExecutionNode"]
 """,
         "nodes/code_execution_node/__init__.py": """
 from typing import Union
@@ -326,11 +305,6 @@ class Workflow(BaseWorkflow):
 
     class Outputs(BaseWorkflow.Outputs):
        final_output = Subworkflow.Outputs.result
-""",
-        "nodes/__init__.py": """
-from .subworkflow import Subworkflow
-
-__all__ = ["Subworkflow"]
 """,
         "nodes/subworkflow/__init__.py": """
 from vellum.workflows.nodes.displayable import InlineSubworkflowNode
@@ -339,11 +313,6 @@ from .workflow import SubworkflowWorkflow
 
 class Subworkflow(InlineSubworkflowNode):
     subworkflow = SubworkflowWorkflow
-""",
-        "nodes/subworkflow/nodes/__init__.py": """
-from .code_execution_node import CodeExecutionNode
-
-__all__ = ["CodeExecutionNode"]
 """,
         "nodes/subworkflow/nodes/code_execution_node/__init__.py": """
 from typing import Union
@@ -424,11 +393,6 @@ class Workflow(BaseWorkflow):
     
     class Outputs(BaseWorkflow.Outputs):  # noqa: W293
        results = MapNode.Outputs.final_output
-""",
-        "nodes/__init__.py": """
-from .map_node import MapNode
-
-__all__ = ["MapNode"]
 """,
         "nodes/map_node/__init__.py": """
 from vellum.workflows.nodes.core.map_node import MapNode as BaseMapNode
@@ -439,11 +403,6 @@ class MapNode(BaseMapNode):
     items = ["foo", "bar", "baz"]
     subworkflow = MapNodeWorkflow
     max_concurrency = 4
-""",
-        "nodes/map_node/nodes/__init__.py": """
-from .code_execution_node import CodeExecutionNode
-
-__all__ = ["CodeExecutionNode"]
 """,
         "nodes/map_node/nodes/code_execution_node/__init__.py": """
 from typing import Union
@@ -520,7 +479,6 @@ from .nodes.broken_node import BrokenNode
 class Workflow(BaseWorkflow):
     graph = BrokenNode
 """,
-        "nodes/__init__.py": "",
         "nodes/broken_node.py": """\
 from vellum.workflows.nodes import BaseNode
 
@@ -559,7 +517,6 @@ from .nodes.broken_node import BrokenNode
 class Workflow(BaseWorkflow):
     graph = BrokenNode
 """,
-        "nodes/__init__.py": "",
         "nodes/broken_node.py": """\
 from vellum.workflows.nodes import BaseNode
 
@@ -819,19 +776,9 @@ class TestSubworkflowDeploymentNode(SubworkflowDeploymentNode):
     files = {
         "__init__.py": "",
         "workflow.py": parent_workflow_code,
-        "nodes/__init__.py": """
-from .subworkflow_deployment_node import TestSubworkflowDeploymentNode
-
-__all__ = ["TestSubworkflowDeploymentNode"]
-""",
         "nodes/subworkflow_deployment_node.py": parent_node_code,
         f"{expected_prefix}/__init__.py": "",
         f"{expected_prefix}/workflow.py": mock_workflow_code,
-        f"{expected_prefix}/nodes/__init__.py": """
-from .test_node import TestNode
-
-__all__ = ["TestNode"]
-""",
         f"{expected_prefix}/nodes/test_node.py": test_node_code,
     }
 
@@ -919,11 +866,6 @@ class TestSubworkflowDeploymentNode(SubworkflowDeploymentNode):
     subworkflow_files = {
         "__init__.py": "",
         "workflow.py": mock_workflow_code,
-        "nodes/__init__.py": """
-from .test_node import TestNode
-
-__all__ = ["TestNode"]
-""",
         "nodes/test_node.py": test_node_code,
     }
 
@@ -931,11 +873,6 @@ __all__ = ["TestNode"]
         "__init__.py": "",
         "inputs.py": inputs_code,
         "workflow.py": parent_workflow_code,
-        "nodes/__init__.py": """
-from .subworkflow_deployment_node import TestSubworkflowDeploymentNode
-
-__all__ = ["TestSubworkflowDeploymentNode"]
-""",
         "nodes/subworkflow_deployment_node.py": parent_node_code,
     }
 
@@ -966,3 +903,81 @@ __all__ = ["TestSubworkflowDeploymentNode"]
 
     # AND the X-Vellum-Always-Success header should be included for graceful error handling
     assert kwargs["request_options"]["additional_headers"]["X-Vellum-Always-Success"] == "true"
+
+
+def test_workflow_initiated_event_includes_display_context_with_output_display_name():
+    """
+    Tests that workflow initiated events include display context with annotated node and output information.
+    """
+    # GIVEN a workflow with a single node that has a single output
+    files = {
+        "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from .nodes.start_node import StartNode
+
+class Workflow(BaseWorkflow):
+    graph = StartNode
+
+    class Outputs(BaseWorkflow.Outputs):
+        final_result = StartNode.Outputs.result
+""",
+        "nodes/start_node.py": """\
+from vellum.workflows.nodes import BaseNode
+
+class StartNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        result: str = "test output"
+""",
+        "display/nodes/__init__.py": """\
+from .start_node import StartNodeDisplay
+""",
+        "display/nodes/start_node.py": """\
+from uuid import UUID
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
+from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
+from ...nodes.start_node import StartNode
+
+class StartNodeDisplay(BaseNodeDisplay[StartNode]):
+    node_id = UUID("11111111-1111-1111-1111-111111111111")
+    output_display = {
+        StartNode.Outputs.result: NodeOutputDisplay(
+            id=UUID("22222222-2222-2222-2222-222222222222"),
+            name="Pretty Result"
+        )
+    }
+""",
+        "display/workflow.py": """\
+""",
+    }
+
+    namespace = str(uuid4())
+    finder = VirtualFileFinder(files, namespace)
+    sys.meta_path.append(finder)
+
+    try:
+        # WHEN we stream the workflow and enrich the initiated event with display context
+        Workflow = BaseWorkflow.load_from_module(namespace)
+        workflow = Workflow()
+        initiated_event = list(workflow.stream())[0]
+        enriched_event = event_enricher(initiated_event)
+
+        # THEN the initiated event should have display context
+        assert isinstance(enriched_event.body, WorkflowExecutionInitiatedBody)
+        body = enriched_event.body
+        assert body.display_context is not None
+
+        # AND the display context should contain the annotated node
+        node_displays = body.display_context.node_displays
+        annotated_node_id = UUID("11111111-1111-1111-1111-111111111111")
+        assert annotated_node_id in node_displays
+
+        # AND the node's output display should contain the output with the display name "Pretty Result"
+        node_display = node_displays[annotated_node_id]
+        assert "result" in node_display.output_display
+
+        # AND the output should map to the annotated output id
+        annotated_output_id = UUID("22222222-2222-2222-2222-222222222222")
+        assert node_display.output_display["result"] == annotated_output_id
+    finally:
+        if finder in sys.meta_path:
+            sys.meta_path.remove(finder)

{vellum_ai-1.8.5 → vellum_ai-1.9.0}/ee/vellum_ee/workflows/tests/test_virtual_files.py

@@ -80,3 +80,51 @@ def test_base_class_dynamic_import(files):
         assert instance.id
     except Exception as e:
         pytest.fail(f"Failed to create an instance of BaseClass: {e}")
+
+
+def test_display_directory_not_auto_generated():
+    """
+    Test that the top-level display directory is NOT auto-generated with empty __init__.py.
+    Display directories typically have specific __init__.py content (e.g., "from .workflow import *")
+    that should not be replaced with empty auto-generated files.
+    """
+    # GIVEN a workflow with display/workflow.py but NO display/__init__.py
+    files = {
+        "__init__.py": "",
+        "workflow.py": """\
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes.bases import BaseNode
+
+class StartNode(BaseNode):
+    pass
+
+class Workflow(BaseWorkflow):
+    graph = StartNode
+""",
+        "display/workflow.py": """\
+from vellum_ee.workflows.display.workflows import BaseWorkflowDisplay
+
+class WorkflowDisplay(BaseWorkflowDisplay):
+    pass
+""",
+        # Note: NO "display/__init__.py" in files dict
+    }
+
+    namespace = str(uuid4())
+
+    # AND the virtual file loader is registered
+    sys.meta_path.append(VirtualFileFinder(files, namespace))
+
+    try:
+        # WHEN we try to resolve display/__init__.py
+        import importlib.util
+
+        spec = importlib.util.find_spec(f"{namespace}.display")
+
+        # THEN the spec should be found because we now support dynamic display module imports
+        assert spec
+        assert spec.origin == "display/__init__.py"
+
+    finally:
+        # Clean up
+        sys.meta_path = [finder for finder in sys.meta_path if not isinstance(finder, VirtualFileFinder)]

{vellum_ai-1.8.5 → vellum_ai-1.9.0}/pyproject.toml

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

{vellum_ai-1.8.5 → vellum_ai-1.9.0}/src/vellum/__init__.py

@@ -13,6 +13,7 @@ from .client.types import (
     AdHocRejectedPromptExecutionMeta,
     AdHocStreamingPromptExecutionMeta,
     AddOpenaiApiKeyEnum,
+    ApiActorTypeEnum,
     ApiNodeResult,
     ApiNodeResultData,
     ApiRequestParentContext,
@@ -233,6 +234,7 @@ from .client.types import (
     IntegrationName,
     IntegrationProvider,
     IntegrationRead,
+    IntegrationTriggerContext,
     InvokedPort,
     IterationStateEnum,
     JinjaPromptBlock,
@@ -425,6 +427,7 @@ from .client.types import (
     ScenarioInputJsonVariableValue,
     ScenarioInputStringVariableValue,
     ScenarioInputVideoVariableValue,
+    ScheduledTriggerContext,
     SearchFiltersRequest,
     SearchNodeResult,
     SearchNodeResultData,
@@ -756,6 +759,7 @@ __all__ = [
     "AdHocRejectedPromptExecutionMeta",
     "AdHocStreamingPromptExecutionMeta",
     "AddOpenaiApiKeyEnum",
+    "ApiActorTypeEnum",
     "ApiNodeResult",
     "ApiNodeResultData",
     "ApiRequestParentContext",
@@ -982,6 +986,7 @@ __all__ = [
     "IntegrationName",
     "IntegrationProvider",
     "IntegrationRead",
+    "IntegrationTriggerContext",
     "InternalServerError",
     "InvokedPort",
     "IterationStateEnum",
@@ -1179,6 +1184,7 @@ __all__ = [
     "ScenarioInputJsonVariableValue",
     "ScenarioInputStringVariableValue",
     "ScenarioInputVideoVariableValue",
+    "ScheduledTriggerContext",
     "SearchFiltersRequest",
     "SearchNodeResult",
     "SearchNodeResultData",

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