vellum-ai 0.14.70__py3-none-any.whl → 0.14.72__py3-none-any.whl

vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.70",
+            "X-Fern-SDK-Version": "0.14.72",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

vellum/plugins/vellum_mypy.py

@@ -573,7 +573,7 @@ class VellumMypyPlugin(Plugin):
         alias_target = alias.target
         if (
             not isinstance(alias_target, Instance)
-            or not _is_subclass(alias_target.type, "typing.Iterator")
+            or not _is_subclass(alias_target.type, "vellum.workflows.events.stream.WorkflowEventGenerator")
             or not alias_target.args
         ):
             return ctx.default_return_type

vellum/workflows/environment/environment.py

@@ -5,8 +5,11 @@ from vellum.workflows.references import EnvironmentVariableReference
 
 class EnvironmentVariables:
     @staticmethod
-    def get(name: str, default: Optional[str] = None) -> EnvironmentVariableReference:
-        return EnvironmentVariableReference(name=name, default=default)
+    def get(name: str, default: Optional[str] = None):
+        env_ref = EnvironmentVariableReference(name=name)
+        if default is not None:
+            return env_ref.coalesce(default)
+        return env_ref
 
 
 # Deprecated: Use EnvironmentVariables instead. Will be removed in v0.15.0

vellum/workflows/events/__init__.py

@@ -5,6 +5,7 @@ from .node import (
     NodeExecutionRejectedEvent,
     NodeExecutionStreamingEvent,
 )
+from .stream import WorkflowEventGenerator
 from .workflow import (
     WorkflowEvent,
     WorkflowEventStream,
@@ -26,4 +27,5 @@ __all__ = [
     "WorkflowExecutionStreamingEvent",
     "WorkflowEvent",
     "WorkflowEventStream",
+    "WorkflowEventGenerator",
 ]

vellum/workflows/events/stream.py

@@ -0,0 +1,28 @@
+from uuid import UUID
+from typing import Generator, Generic, Iterator, TypeVar
+
+EventType = TypeVar("EventType")
+
+
+class WorkflowEventGenerator(Generic[EventType]):
+    """
+    Generic wrapper for event streams that exposes span_id as a top-level property
+    while maintaining iterator compatibility.
+    """
+
+    def __init__(self, event_generator: Generator[EventType, None, None], span_id: UUID):
+        self._event_generator = event_generator
+        self._span_id = span_id
+
+    @property
+    def span_id(self) -> UUID:
+        """The span_id associated with this workflow stream."""
+        return self._span_id
+
+    def __iter__(self) -> Iterator[EventType]:
+        """Return self to make this object iterable."""
+        return self
+
+    def __next__(self) -> EventType:
+        """Get the next event from the underlying generator."""
+        return next(self._event_generator)

vellum/workflows/events/workflow.py

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import TYPE_CHECKING, Any, Dict, Generator, Generic, Iterable, Literal, Optional, Type, Union
+from typing import TYPE_CHECKING, Any, Dict, Generic, Iterable, Literal, Optional, Type, Union
 from typing_extensions import TypeGuard
 
 from pydantic import field_serializer
@@ -19,6 +19,7 @@ from .node import (
     NodeExecutionResumedEvent,
     NodeExecutionStreamingEvent,
 )
+from .stream import WorkflowEventGenerator
 from .types import BaseEvent, default_serializer
 
 if TYPE_CHECKING:
@@ -193,7 +194,7 @@ WorkflowEvent = Union[
     WorkflowExecutionSnapshottedEvent,
 ]
 
-WorkflowEventStream = Generator[WorkflowEvent, None, None]
+WorkflowEventStream = WorkflowEventGenerator[WorkflowEvent]
 
 WorkflowExecutionEvent = Union[
     WorkflowExecutionInitiatedEvent,

vellum/workflows/nodes/displayable/code_execution_node/node.py

@@ -98,7 +98,7 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
     def run(self) -> Outputs:
         output_type = self.__class__.get_output_type()
         code, filepath = self._resolve_code()
-        if not self.packages and self.runtime == "PYTHON_3_11_6":
+        if not self.packages and self.runtime == "PYTHON_3_11_6" and not self._has_secrets_in_code_inputs():
             logs, result = run_code_inline(code, self.code_inputs, output_type, filepath)
             return self.Outputs(result=result, log=logs)
 
@@ -133,6 +133,13 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
 
             return self.Outputs(result=code_execution_result.output.value, log=code_execution_result.log)
 
+    def _has_secrets_in_code_inputs(self) -> bool:
+        """Check if any code_inputs contain VellumSecret instances that require API execution."""
+        for input_value in self.code_inputs.values():
+            if isinstance(input_value, VellumSecret):
+                return True
+        return False
+
     def _compile_code_inputs(self) -> List[CodeExecutorInput]:
         # TODO: We may want to consolidate with prompt deployment input compilation
         # https://app.shortcut.com/vellum/story/4117

vellum/workflows/nodes/displayable/code_execution_node/tests/test_node.py

@@ -1233,3 +1233,56 @@ def main(numbers: List[str]) -> str:
         ],
         request_options=None,
     )
+
+
+def test_run_node__vellum_secret_forces_api_execution(vellum_client):
+    """Test that CodeExecutionNode with VellumSecretReference forces API execution instead of inline execution."""
+
+    # GIVEN a node that subclasses CodeExecutionNode with VellumSecretReference but no packages
+    # This should normally run inline, but the presence of secrets should force API execution
+    class State(BaseState):
+        pass
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, str]):
+        code = """
+def main(secret: str) -> str:
+    return f"Secret value: {secret}"
+"""
+        runtime = "PYTHON_3_11_6"
+        # Note: No packages specified, which would normally trigger inline execution
+
+        code_inputs = {
+            "secret": VellumSecretReference("MY_SECRET"),
+        }
+
+    # AND we know what the Code Execution Node will respond with
+    mock_code_execution = CodeExecutorResponse(
+        log="",
+        output=StringVellumValue(value="Secret value: my_secret_value"),
+    )
+    vellum_client.execute_code.return_value = mock_code_execution
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode(state=State())
+    outputs = node.run()
+
+    # THEN the node should have produced the outputs we expect
+    assert outputs == {"result": "Secret value: my_secret_value", "log": ""}
+
+    # AND we should have invoked the Code via API (not inline) due to the secret
+    vellum_client.execute_code.assert_called_once_with(
+        input_values=[
+            CodeExecutorSecretInput(
+                name="secret",
+                value="MY_SECRET",
+            )
+        ],
+        code="""
+def main(secret: str) -> str:
+    return f"Secret value: {secret}"
+""",
+        runtime="PYTHON_3_11_6",
+        output_type="STRING",
+        packages=[],
+        request_options=None,
+    )

vellum/workflows/nodes/experimental/tool_calling_node/node.py

@@ -110,7 +110,7 @@ class ToolCallingNode(BaseNode):
 
             # Get configuration for this function
             config = {}
-            if self.function_configs and function.__name__ in self.function_configs:
+            if callable(function) and self.function_configs and function.__name__ in self.function_configs:
                 config = self.function_configs[function.__name__]
 
             packages = config.get("packages", None)

vellum/workflows/nodes/experimental/tool_calling_node/utils.py

@@ -145,7 +145,7 @@ def create_function_node(
     """
     if is_workflow_class(function):
         # Create a class-level wrapper that calls the original function
-        def execute_function(self) -> BaseNode.Outputs:
+        def execute_inline_workflow_function(self) -> BaseNode.Outputs:
             outputs = self.state.meta.node_outputs.get(tool_router_node.Outputs.text)
 
             outputs = json.loads(outputs)
@@ -181,7 +181,7 @@ def create_function_node(
             f"InlineWorkflowNode_{function.__name__}",
             (FunctionNode,),
             {
-                "run": execute_function,
+                "run": execute_inline_workflow_function,
                 "__module__": __name__,
             },
         )

vellum/workflows/references/environment_variable.py

@@ -1,6 +1,7 @@
 import os
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 
 if TYPE_CHECKING:
@@ -8,16 +9,18 @@ if TYPE_CHECKING:
 
 
 class EnvironmentVariableReference(BaseDescriptor[str]):
-    def __init__(self, *, name: str, default: Optional[str] = None):
+    def __init__(
+        self,
+        *,
+        name: str,
+        # DEPRECATED - to be removed in 0.15.0 release
+        default: Optional[str] = None,
+    ):
         super().__init__(name=name, types=(str,))
-        self._default = default
 
-    def resolve(self, state: "BaseState") -> str:
+    def resolve(self, state: "BaseState") -> Any:
         env_value = os.environ.get(self.name)
         if env_value is not None:
             return env_value
 
-        if self._default is not None:
-            return self._default
-
-        return ""
+        return undefined

vellum/workflows/runner/runner.py

@@ -5,7 +5,21 @@ import logging
 from queue import Empty, Queue
 from threading import Event as ThreadingEvent, Thread
 from uuid import UUID, uuid4
-from typing import TYPE_CHECKING, Any, Dict, Generic, Iterable, Iterator, Optional, Sequence, Set, Tuple, Type, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Generator,
+    Generic,
+    Iterable,
+    Iterator,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    Union,
+)
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.context import ExecutionContext, execution_context, get_execution_context
@@ -17,7 +31,7 @@ from vellum.workflows.events import (
     NodeExecutionRejectedEvent,
     NodeExecutionStreamingEvent,
     WorkflowEvent,
-    WorkflowEventStream,
+    WorkflowEventGenerator,
     WorkflowExecutionFulfilledEvent,
     WorkflowExecutionInitiatedEvent,
     WorkflowExecutionRejectedEvent,
@@ -31,6 +45,7 @@ from vellum.workflows.events.node import (
 )
 from vellum.workflows.events.types import BaseEvent, NodeParentContext, ParentContext, WorkflowParentContext
 from vellum.workflows.events.workflow import (
+    WorkflowEventStream,
     WorkflowExecutionFulfilledBody,
     WorkflowExecutionInitiatedBody,
     WorkflowExecutionPausedBody,
@@ -730,7 +745,7 @@ class WorkflowRunner(Generic[StateType]):
             return event.workflow_definition == self.workflow.__class__
         return False
 
-    def stream(self) -> WorkflowEventStream:
+    def _generate_events(self) -> Generator[WorkflowEvent, None, None]:
         background_thread = Thread(
             target=self._run_background_thread,
             name=f"{self.workflow.__class__.__name__}.background_thread",
@@ -788,3 +803,6 @@ class WorkflowRunner(Generic[StateType]):
 
         self._background_thread_queue.put(None)
         cancel_thread_kill_switch.set()
+
+    def stream(self) -> WorkflowEventStream:
+        return WorkflowEventGenerator(self._generate_events(), self._initial_state.meta.span_id)

vellum/workflows/utils/functions.py

@@ -1,12 +1,14 @@
 import dataclasses
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Optional, Type, Union, get_args, get_origin
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Type, Union, get_args, get_origin
 
 from pydantic import BaseModel
 from pydantic_core import PydanticUndefined
 from pydash import snake_case
 
+from vellum import Vellum
 from vellum.client.types.function_definition import FunctionDefinition
+from vellum.workflows.utils.vellum_variables import vellum_variable_type_to_openapi_type
 
 if TYPE_CHECKING:
     from vellum.workflows.workflows.base import BaseWorkflow
@@ -86,6 +88,19 @@ def _compile_default_value(default: Any) -> Any:
     return default
 
 
+def _compile_deployment_workflow_input(input_var: Any) -> dict[str, Any]:
+    """
+    Converts a deployment workflow input variable to a JSON schema type definition.
+    """
+    primitive_type = vellum_variable_type_to_openapi_type(input_var.type)
+    input_schema = {"type": primitive_type}
+
+    if input_var.default is not None:
+        input_schema["default"] = input_var.default.value
+
+    return input_schema
+
+
 def compile_function_definition(function: Callable) -> FunctionDefinition:
     """
     Converts a Python function into our Vellum-native FunctionDefinition type.
@@ -151,3 +166,42 @@ def compile_workflow_function_definition(workflow_class: Type["BaseWorkflow"]) -
         description=workflow_class.__doc__,
         parameters=parameters,
     )
+
+
+def compile_deployment_workflow_function_definition(
+    deployment_config: Dict[str, str],
+    vellum_client: Vellum,
+) -> FunctionDefinition:
+    """
+    Converts a deployment workflow config into our Vellum-native FunctionDefinition type.
+
+    Args:
+        deployment_config: Dict with 'deployment' and 'release_tag' keys
+        vellum_client: Vellum client instance
+    """
+    deployment = deployment_config["deployment"]
+    release_tag = deployment_config["release_tag"]
+
+    workflow_deployment_release = vellum_client.release_reviews.retrieve_workflow_deployment_release(
+        deployment, release_tag
+    )
+
+    input_variables = workflow_deployment_release.workflow_version.input_variables
+    description = workflow_deployment_release.description
+
+    properties = {}
+    required = []
+
+    for input_var in input_variables:
+        properties[input_var.key] = _compile_deployment_workflow_input(input_var)
+
+        if input_var.required and input_var.default is None:
+            required.append(input_var.key)
+
+    parameters = {"type": "object", "properties": properties, "required": required}
+
+    return FunctionDefinition(
+        name=deployment,
+        description=description,
+        parameters=parameters,
+    )

vellum/workflows/utils/tests/test_functions.py

@@ -1,14 +1,21 @@
 from dataclasses import dataclass
+from unittest.mock import Mock
 from typing import Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
 from vellum.client.types.function_definition import FunctionDefinition
+from vellum.client.types.string_vellum_value import StringVellumValue
+from vellum.client.types.vellum_variable import VellumVariable
 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.utils.functions import compile_function_definition, compile_workflow_function_definition
+from vellum.workflows.utils.functions import (
+    compile_deployment_workflow_function_definition,
+    compile_function_definition,
+    compile_workflow_function_definition,
+)
 
 
 def test_compile_function_definition__just_name():
@@ -431,3 +438,146 @@ def test_compile_workflow_function_definition__optionals():
             "required": ["a", "b", "c"],
         },
     )
+
+
+def test_compile_deployment_workflow_function_definition__just_name():
+    # GIVEN a mock Vellum client and deployment
+    mock_client = Mock()
+    mock_release = Mock()
+    mock_release.workflow_version.input_variables = []
+    mock_release.description = "This is a test deployment"
+    mock_client.release_reviews.retrieve_workflow_deployment_release.return_value = mock_release
+
+    deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
+
+    # WHEN compiling the deployment workflow function
+    compiled_function = compile_deployment_workflow_function_definition(deployment_config, mock_client)
+
+    # THEN it should return the compiled function definition (same structure as function test)
+    assert compiled_function == FunctionDefinition(
+        name="my_deployment",
+        description="This is a test deployment",
+        parameters={"type": "object", "properties": {}, "required": []},
+    )
+
+
+def test_compile_deployment_workflow_function_definition__all_args():
+    # GIVEN a mock Vellum client and deployment
+    mock_client = Mock()
+    mock_release = Mock()
+
+    mock_inputs = []
+    for key, vellum_type in [
+        ("a", "STRING"),
+        ("b", "NUMBER"),
+        ("c", "JSON"),
+        ("d", "CHAT_HISTORY"),
+        ("e", "SEARCH_RESULTS"),
+        ("f", "ERROR"),
+        ("g", "ARRAY"),
+        ("h", "FUNCTION_CALL"),
+        ("i", "IMAGE"),
+        ("j", "AUDIO"),
+        ("k", "DOCUMENT"),
+        ("l", "NULL"),
+    ]:
+        mock_input = VellumVariable(
+            id=f"input_{key}",
+            key=key,
+            type=vellum_type,
+            required=True,
+            default=None,
+        )
+        mock_inputs.append(mock_input)
+
+    mock_release.workflow_version.input_variables = mock_inputs
+    mock_release.description = "This is a test deployment"
+    mock_client.release_reviews.retrieve_workflow_deployment_release.return_value = mock_release
+
+    deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
+
+    # WHEN compiling the deployment workflow function
+    compiled_function = compile_deployment_workflow_function_definition(deployment_config, mock_client)
+
+    # THEN it should return the compiled function definition
+    assert compiled_function == FunctionDefinition(
+        name="my_deployment",
+        description="This is a test deployment",
+        parameters={
+            "type": "object",
+            "properties": {
+                "a": {"type": "string"},
+                "b": {"type": "number"},
+                "c": {"type": "object"},
+                "d": {"type": "array"},
+                "e": {"type": "array"},
+                "f": {"type": "object"},
+                "g": {"type": "array"},
+                "h": {"type": "object"},
+                "i": {"type": "object"},
+                "j": {"type": "object"},
+                "k": {"type": "object"},
+                "l": {"type": "null"},
+            },
+            "required": ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"],
+        },
+    )
+
+
+def test_compile_deployment_workflow_function_definition__defaults():
+    # GIVEN a mock Vellum client and deployment
+    mock_client = Mock()
+    mock_release = Mock()
+
+    mock_inputs = []
+
+    mock_input_no_default = VellumVariable(
+        id="no_default",
+        key="no_default",
+        type="STRING",
+        required=True,
+        default=None,
+    )
+    mock_inputs.append(mock_input_no_default)
+
+    mock_input_null_default = VellumVariable(
+        id="null_default",
+        key="null_default",
+        type="STRING",
+        required=False,
+        default=StringVellumValue(value=None),
+    )
+    mock_inputs.append(mock_input_null_default)
+
+    mock_input_actual_default = VellumVariable(
+        id="actual_default",
+        key="actual_default",
+        type="STRING",
+        required=False,
+        default=StringVellumValue(value="hello world"),
+    )
+    mock_inputs.append(mock_input_actual_default)
+
+    mock_release.workflow_version.input_variables = mock_inputs
+    mock_release.description = "This is a test deployment"
+    mock_client.release_reviews.retrieve_workflow_deployment_release.return_value = mock_release
+
+    deployment_config = {"deployment": "my_deployment", "release_tag": "latest"}
+
+    # WHEN compiling the deployment workflow function
+    compiled_function = compile_deployment_workflow_function_definition(deployment_config, mock_client)
+
+    # THEN it should return the compiled function definition with proper default handling
+    assert compiled_function == FunctionDefinition(
+        name="my_deployment",
+        description="This is a test deployment",
+        parameters={
+            "type": "object",
+            "properties": {
+                "no_default": {"type": "string"},
+                "null_default": {"type": "string", "default": None},
+                "actual_default": {"type": "string", "default": "hello world"},
+            },
+            "required": ["no_default"],
+        },
+    )

vellum/workflows/utils/tests/test_vellum_variables.py

@@ -3,7 +3,10 @@ from typing import List, Optional
 
 from vellum import ChatMessage, SearchResult, VellumAudio, VellumDocument, VellumImage
 from vellum.workflows.types.core import Json
-from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
+from vellum.workflows.utils.vellum_variables import (
+    primitive_type_to_vellum_variable_type,
+    vellum_variable_type_to_openapi_type,
+)
 
 
 @pytest.mark.parametrize(
@@ -31,3 +34,24 @@ from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_var
 )
 def test_primitive_type_to_vellum_variable_type(type_, expected):
     assert primitive_type_to_vellum_variable_type(type_) == expected
+
+
+@pytest.mark.parametrize(
+    "vellum_type, expected",
+    [
+        ("STRING", "string"),
+        ("NUMBER", "number"),
+        ("JSON", "object"),
+        ("CHAT_HISTORY", "array"),
+        ("SEARCH_RESULTS", "array"),
+        ("ERROR", "object"),
+        ("ARRAY", "array"),
+        ("FUNCTION_CALL", "object"),
+        ("IMAGE", "object"),
+        ("AUDIO", "object"),
+        ("DOCUMENT", "object"),
+        ("NULL", "null"),
+    ],
+)
+def test_vellum_variable_type_to_openapi_type(vellum_type, expected):
+    assert vellum_variable_type_to_openapi_type(vellum_type) == expected

vellum/workflows/utils/vellum_variables.py

@@ -78,6 +78,36 @@ def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -
     return "JSON"
 
 
+def vellum_variable_type_to_openapi_type(vellum_type: VellumVariableType) -> str:
+    """Converts a VellumVariableType to a JSON schema primitive type string"""
+    if vellum_type == "STRING":
+        return "string"
+    elif vellum_type == "NUMBER":
+        return "number"
+    elif vellum_type == "JSON":
+        return "object"
+    elif vellum_type == "CHAT_HISTORY":
+        return "array"
+    elif vellum_type == "SEARCH_RESULTS":
+        return "array"
+    elif vellum_type == "ERROR":
+        return "object"
+    elif vellum_type == "ARRAY":
+        return "array"
+    elif vellum_type == "FUNCTION_CALL":
+        return "object"
+    elif vellum_type == "IMAGE":
+        return "object"
+    elif vellum_type == "AUDIO":
+        return "object"
+    elif vellum_type == "DOCUMENT":
+        return "object"
+    elif vellum_type == "NULL":
+        return "null"
+    else:
+        return "object"
+
+
 def _is_type_optionally_equal(type_: Type, target_type: Type) -> bool:
     if type_ == target_type:
         return True

vellum/workflows/workflows/base.py

@@ -42,6 +42,7 @@ from vellum.workflows.events.node import (
     NodeExecutionStreamingBody,
     NodeExecutionStreamingEvent,
 )
+from vellum.workflows.events.stream import WorkflowEventGenerator
 from vellum.workflows.events.workflow import (
     GenericWorkflowEvent,
     WorkflowExecutionFulfilledBody,
@@ -167,7 +168,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         WorkflowExecutionPausedEvent,
     ]
 
-    WorkflowEventStream = Generator[WorkflowEvent, None, None]
+    WorkflowEventStream = WorkflowEventGenerator[WorkflowEvent]
 
     def __init__(
         self,
@@ -444,7 +445,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
         """
 
         should_yield = event_filter or workflow_event_filter
-        for event in WorkflowRunner(
+        runner_stream = WorkflowRunner(
             self,
             inputs=inputs,
             state=state,
@@ -454,9 +455,14 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
             node_output_mocks=node_output_mocks,
             max_concurrency=max_concurrency,
             init_execution_context=self._execution_context,
-        ).stream():
-            if should_yield(self.__class__, event):
-                yield event
+        ).stream()
+
+        def _generate_filtered_events() -> Generator[BaseWorkflow.WorkflowEvent, None, None]:
+            for event in runner_stream:
+                if should_yield(self.__class__, event):
+                    yield event
+
+        return WorkflowEventGenerator(_generate_filtered_events(), runner_stream.span_id)
 
     def validate(self) -> None:
         """

{vellum_ai-0.14.70.dist-info → vellum_ai-0.14.72.dist-info}/METADATA

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