vellum-ai 0.14.71__tar.gz → 0.14.72__tar.gz

{vellum_ai-0.14.71 → vellum_ai-0.14.72}/PKG-INFO

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

{vellum_ai-0.14.71 → vellum_ai-0.14.72}/ee/vellum_cli/image_push.py

@@ -30,12 +30,8 @@ def image_push_command(
         if not os.path.exists(source):
             handle_cli_error(logger, "Dockerfile not found", f"Dockerfile does not exist: {source}")
 
-        source_dir = os.path.dirname(source)
-        dockerfile_name = os.path.basename(source)
-
         build_result = subprocess.run(
-            ["docker", "buildx", "build", "-f", dockerfile_name, "--platform=linux/amd64", "-t", image, "."],
-            cwd=source_dir,
+            ["docker", "buildx", "build", "-f", source, "--platform=linux/amd64", "-t", image, "."],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
         )

{vellum_ai-0.14.71 → vellum_ai-0.14.72}/ee/vellum_cli/push.py

@@ -242,6 +242,13 @@ def push_command(
 {json.dumps(response.proposed_diffs, indent=2)}
 """
         )  # type: ignore[attr-defined]
+
+        error_list = list(workflow_display.errors)
+        has_errors = len(error_list) > 0
+        has_diffs = response.proposed_diffs is not None and response.proposed_diffs
+
+        if has_errors or has_diffs:
+            exit(1)
     else:
         default_api_url = client._client_wrapper._environment.default
         base_url = default_api_url.split("/v1")[0].replace("//api.", "//app.")

{vellum_ai-0.14.71 → vellum_ai-0.14.72}/ee/vellum_cli/tests/test_image_push.py

@@ -209,13 +209,12 @@ def test_image_push_with_source_success(
         "buildx",
         "build",
         "-f",
-        "Dockerfile",
+        dockerfile_path,
         "--platform=linux/amd64",
         "-t",
         "myimage:latest",
         ".",
     ]
-    assert build_call[1]["cwd"] == mock_temp_dir
 
     assert "Docker build completed successfully" in result.output
     assert "Image successfully pushed" in result.output

{vellum_ai-0.14.71 → vellum_ai-0.14.72}/ee/vellum_cli/tests/test_push.py

@@ -444,8 +444,8 @@ class ExampleWorkflow(BaseWorkflow):
     runner = CliRunner(mix_stderr=True)
     result = runner.invoke(cli_main, ["push", module, "--dry-run"])
 
-    # THEN it should succeed
-    assert result.exit_code == 0
+    # THEN it should fail with exit code 1 due to errors
+    assert result.exit_code == 1
 
     # AND we should have called the push API with the dry-run option
     vellum_client.workflows.push.assert_called_once()
@@ -459,6 +459,37 @@ class ExampleWorkflow(BaseWorkflow):
     assert "iterable_item_added" in result.output
 
 
+def test_push__dry_run_option_no_errors_returns_success(mock_module, vellum_client):
+    """Test that dry-run returns exit code 0 when there are no errors or diffs"""
+    # GIVEN a workflow module with a valid workflow (using the same pattern as happy path test)
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns successfully with no errors and no diffs
+    vellum_client.workflows.push.return_value = WorkflowPushResponse(
+        workflow_sandbox_id=str(uuid4()),
+        proposed_diffs=None,
+    )
+
+    # WHEN calling `vellum push` with dry-run
+    runner = CliRunner(mix_stderr=True)
+    result = runner.invoke(cli_main, ["push", module, "--dry-run"])
+
+    # THEN it should succeed with exit code 0
+    assert result.exit_code == 0
+
+    # AND we should have called the push API with the dry-run option
+    vellum_client.workflows.push.assert_called_once()
+    call_args = vellum_client.workflows.push.call_args.kwargs
+    assert call_args["dry_run"] is True
+
+    # AND the report should be in the output
+    assert "## Errors" in result.output
+    assert "No errors found." in result.output
+    assert "## Proposed Diffs" in result.output
+
+
 def test_push__strict_option_returns_diffs(mock_module, vellum_client):
     # GIVEN a single workflow configured
     temp_dir = mock_module.temp_dir

{vellum_ai-0.14.71 → vellum_ai-0.14.72}/ee/vellum_ee/workflows/display/nodes/utils.py

@@ -8,11 +8,11 @@ _T = TypeVar("_T")
 
 
 @overload
-def raise_if_descriptor(_node_attr: BaseDescriptor[_T]) -> _T: ...
+def raise_if_descriptor(node_attr: BaseDescriptor[_T]) -> _T: ...
 
 
 @overload
-def raise_if_descriptor(_node_attr: _T) -> _T: ...
+def raise_if_descriptor(node_attr: _T) -> _T: ...
 
 
 def raise_if_descriptor(node_attr: Union[NodeReference[_T], _T]) -> Optional[_T]:

vellum_ai-0.14.72/pyproject.toml

@@ -0,0 +1,142 @@
+[project]
+name = "vellum-ai"
+
+[tool.poetry]
+name = "vellum-ai"
+version = "0.14.72"
+description = ""
+readme = "README.md"
+authors = []
+keywords = []
+license = "MIT"
+classifiers = [
+    "Intended Audience :: Developers",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+    "Operating System :: POSIX",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: Microsoft :: Windows",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+    "License :: OSI Approved :: MIT License"
+]
+urls = { Repository = "https://github.com/vellum-ai/vellum-python-sdks" }
+packages = [
+    { include = "vellum", from = "src" },
+    { include = "vellum_cli", from = "ee" },
+    { include = "vellum_ee", from = "ee" },
+]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+Jinja2 = ">=3.1.0,<4.0.0"
+click = ">=8.1.7,<9.0.0"
+docker = ">=7.1.0,<8.0.0"
+httpx = ">=0.21.2"
+openai = ">=1.0.0,<2.0.0"
+orderly-set = "^5.2.2"
+publication = "0.0.3"
+pydantic = ">= 1.9.2"
+pydantic-core = "^2.18.2"
+pydash = ">=7.0.0,<8.0.0"
+python-dateutil = ">=2.8.0,<3.0.0"
+python-dotenv = ">=1.0.0,<2.0.0"
+pytz = ">=2022.0,<2026.0"
+pyyaml = ">=6.0.0,<7.0.0"
+requests = ">=2.31.0,<3.0.0"
+tomli = ">=2.0.0,<3.0.0"
+typing_extensions = ">= 4.0.0"
+
+[tool.poetry.dev-dependencies]
+mypy = "1.11.1"
+pytest = "^7.4.0"
+pytest-asyncio = "^0.23.5"
+python-dateutil = "^2.9.0"
+types-python-dateutil = "^2.9.0.20240316"
+black = "24.8.0"
+deepdiff = "8.0.1"
+flake8 = "7.1.1"
+flake8-breakpoint = "1.1.0"
+flake8-isort = "6.1.1"
+flake8-print = "5.0.0"
+flake8-pyproject = "1.2.3"
+flake8-unused-arguments = "^0.0.13"
+ipdb = "0.13.13"
+ipython = "8.12.3"
+isort = "5.13.2"
+pre-commit = "3.5.0"
+pytest-mock = "3.10.0"
+pytest-timeout = "2.3.1"
+requests-mock = "1.11.0"
+ruff = "^0.5.6"
+tomli_w = "1.1.0"
+types-PyYAML = "6.0.12.20240808"
+types-pytz = "2024.1.0.20240417"
+types-requests = "2.32.0.20240712"
+
+[tool.pytest.ini_options]
+testpaths = [ "tests" ]
+asyncio_mode = "auto"
+filterwarnings = [
+    "ignore::pytest.PytestCollectionWarning"
+]
+
+[tool.mypy]
+plugins = [
+    "pydantic.mypy",
+    "vellum.plugins.vellum_mypy",
+]
+check_untyped_defs = true
+exclude = ["venv", "examples/workflows"]
+overrides = [
+    { module = "deepdiff.*", ignore_missing_imports = true },
+    { module = "docker.*", ignore_missing_imports = true },
+    { module = "setuptools.*", ignore_missing_imports = true },
+]
+[tool.ruff]
+line-length = 120
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+vellum = "vellum_cli:main"
+
+[tool.isort]
+skip = ["src/vellum/client", "tests/client", ".venv", "src/vellum/__init__.py", "examples/workflows"]
+multi_line_output = 3
+force_grid_wrap = 0
+line_length = 120
+combine_as_imports = true
+force_sort_within_sections = true
+include_trailing_comma = true
+use_parentheses = true
+known_testing = "pytest"
+known_typing = ["typing", "typing_extensions"]
+known_vellum = ["vellum", "vellum_cli", "vellum_ee"]
+default_section = "THIRDPARTY"
+sections = ["FUTURE", "TESTING", "STDLIB", "TYPING", "THIRDPARTY", "VELLUM", "FIRSTPARTY", "LOCALFOLDER"]
+no_lines_before = ["STDLIB", "TYPING"]
+sort_order = "native"
+
+[tool.black]
+line-length = 120
+target-version = [
+    "py38",
+]
+include = ".*\\.py$"
+exclude = "(.git|venv|src/vellum/client|tests/client|scripts|examples/workflows)"
+
+[tool.flake8]
+max-line-length = 120
+exclude = ".git,.venv,ee/codegen/node_modules,ee/codegen_integration/fixtures,scripts,src/vellum/__init__.py,src/vellum/client,src/vellum/core,src/vellum/environment.py,src/vellum/errors,src/vellum/resources,src/vellum/types,tests/client,examples/workflows"
+ignore = "E203, W503, E704, U100, U101"

{vellum_ai-0.14.71 → vellum_ai-0.14.72}/src/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.71",
+            "X-Fern-SDK-Version": "0.14.72",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

{vellum_ai-0.14.71 → vellum_ai-0.14.72}/src/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_ai-0.14.71 → vellum_ai-0.14.72}/src/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_ai-0.14.72/src/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_ai-0.14.71 → vellum_ai-0.14.72}/src/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_ai-0.14.71 → vellum_ai-0.14.72}/src/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_ai-0.14.71 → vellum_ai-0.14.72}/src/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_ai-0.14.71 → vellum_ai-0.14.72}/src/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_ai-0.14.71 → vellum_ai-0.14.72}/src/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_ai-0.14.71 → vellum_ai-0.14.72}/src/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"],
+        },
+    )