vellum-ai 1.11.2__py3-none-any.whl → 1.13.5__py3-none-any.whl

vellum_cli/__init__.py

@@ -208,6 +208,11 @@ Helpful for running and debugging workflows locally.""",
     help="""Directory to pull the workflow into. If not specified, \
 the workflow will be pulled into the current working directory.""",
 )
+@click.option(
+    "--release-tag",
+    type=str,
+    help="""Release tag to use when pulling from a deployment.""",
+)
 def pull(
     ctx: click.Context,
     include_json: Optional[bool],
@@ -215,6 +220,7 @@ def pull(
     strict: Optional[bool],
     include_sandbox: Optional[bool],
     target_directory: Optional[str],
+    release_tag: Optional[str],
 ) -> None:
     """Pull Resources from Vellum"""
 
@@ -225,6 +231,7 @@ def pull(
             strict=strict,
             include_sandbox=include_sandbox,
             target_directory=target_directory,
+            release_tag=release_tag,
         )
 
 
@@ -271,6 +278,11 @@ the workflow will be pulled into the current working directory.""",
     type=str,
     help="The specific Workspace config to use when pulling",
 )
+@click.option(
+    "--release-tag",
+    type=str,
+    help="""Release tag to use when pulling from a deployment.""",
+)
 def workflows_pull(
     module: Optional[str],
     include_json: Optional[bool],
@@ -281,6 +293,7 @@ def workflows_pull(
     include_sandbox: Optional[bool],
     target_directory: Optional[str],
     workspace: Optional[str],
+    release_tag: Optional[str],
 ) -> None:
     """
     Pull Workflows from Vellum. If a module is provided, only the Workflow for that module will be pulled.
@@ -297,6 +310,7 @@ def workflows_pull(
         include_sandbox=include_sandbox,
         target_directory=target_directory,
         workspace=workspace,
+        release_tag=release_tag,
     )
 
 
@@ -332,6 +346,11 @@ Helpful for running and debugging resources locally.""",
     help="""Directory to pull the workflow into. If not specified, \
 the workflow will be pulled into the current working directory.""",
 )
+@click.option(
+    "--release-tag",
+    type=str,
+    help="""Release tag to use when pulling from a deployment.""",
+)
 def pull_module(
     ctx: click.Context,
     include_json: Optional[bool],
@@ -339,6 +358,7 @@ def pull_module(
     strict: Optional[bool],
     include_sandbox: Optional[bool],
     target_directory: Optional[str],
+    release_tag: Optional[str],
 ) -> None:
     """Pull a specific module from Vellum"""
 
@@ -350,6 +370,7 @@ def pull_module(
             strict=strict,
             include_sandbox=include_sandbox,
             target_directory=target_directory,
+            release_tag=release_tag,
         )
 
 

vellum_cli/config.py

@@ -120,22 +120,36 @@ def merge_workflows_by_sandbox_id(
         else:
             # If the user defines a workflow in the pyproject.toml with a sandbox_id,
             # we merge the workflow with one of the ones in the lockfile with the same sandbox_id.
+            # First, try to find a lockfile workflow matching both sandbox_id AND workspace.
             other_workflow = next(
                 (
                     other_workflow
                     for other_workflow in other_workflows
                     if self_workflow.workflow_sandbox_id == other_workflow.workflow_sandbox_id
+                    and self_workflow.workspace == other_workflow.workspace
                 ),
                 None,
             )
+            # If no exact match, fall back to matching by sandbox_id alone.
+            if other_workflow is None:
+                other_workflow = next(
+                    (
+                        other_workflow
+                        for other_workflow in other_workflows
+                        if self_workflow.workflow_sandbox_id == other_workflow.workflow_sandbox_id
+                    ),
+                    None,
+                )
             if other_workflow is not None:
                 merged_workflows.append(self_workflow.merge(other_workflow))
             else:
                 merged_workflows.append(self_workflow)
 
-    workflow_sandbox_ids_so_far = {workflow.workflow_sandbox_id for workflow in merged_workflows}
+    # Use (workflow_sandbox_id, workspace) as the dedupe key to preserve workflows
+    # with the same sandbox_id but different workspaces.
+    workflow_keys_so_far = {(workflow.workflow_sandbox_id, workflow.workspace) for workflow in merged_workflows}
     for other_workflow in other_workflows:
-        if other_workflow.workflow_sandbox_id not in workflow_sandbox_ids_so_far:
+        if (other_workflow.workflow_sandbox_id, other_workflow.workspace) not in workflow_keys_so_far:
             merged_workflows.append(other_workflow)
 
     return merged_workflows

vellum_cli/pull.py

@@ -145,6 +145,7 @@ def pull_command(
     include_sandbox: Optional[bool] = None,
     target_directory: Optional[str] = None,
     workspace: Optional[str] = None,
+    release_tag: Optional[str] = None,
 ) -> None:
     load_dotenv(dotenv_path=os.path.join(os.getcwd(), ".env"))
     logger = load_cli_logger()
@@ -198,6 +199,7 @@ def pull_command(
 
     response = client.workflows.pull(
         pk,
+        release_tag=release_tag,
         request_options={"additional_query_parameters": query_parameters},
     )
 

vellum_cli/push.py

@@ -130,13 +130,25 @@ def push_command(
     )
     sys.path.insert(0, os.getcwd())
 
-    # Remove this once we could serialize using the artifact in Vembda
-    # https://app.shortcut.com/vellum/story/5585
-    serialization_result = BaseWorkflowDisplay.serialize_module(
-        workflow_config.module,
-        client=client,
-        dry_run=dry_run or False,
-    )
+    try:
+        serialization_result = BaseWorkflowDisplay.serialize_module(
+            workflow_config.module,
+            client=client,
+            dry_run=dry_run or False,
+        )
+    except ValidationError as e:
+        handle_cli_error(
+            logger,
+            title=f"Validation error while trying to push {workflow_config.module}",
+            message=str(e),
+        )
+    except Exception as e:
+        handle_cli_error(
+            logger,
+            title=f"Error while trying to push {workflow_config.module}",
+            message=str(e),
+        )
+
     exec_config = serialization_result.exec_config
 
     container_tag = workflow_config.container_image_tag
@@ -189,7 +201,7 @@ def push_command(
         module_dir = workflow_config.module.replace(".", os.path.sep)
         for root, _, files in os.walk(module_dir):
             for filename in files:
-                if not filename.endswith(".py"):
+                if not BaseWorkflowDisplay.should_include_file(filename):
                     continue
 
                 file_path = os.path.join(root, filename)
@@ -208,16 +220,17 @@ def push_command(
 
     provided_id = workflow_config.workflow_sandbox_id or workflow_sandbox_id
 
+    dataset_serialized = json.dumps(serialization_result.dataset) if serialization_result.dataset else OMIT
+
     try:
         response = client.workflows.push(
-            # Remove this once we could serialize using the artifact in Vembda
-            # https://app.shortcut.com/vellum/story/5585
             exec_config=json.dumps(exec_config),
             workflow_sandbox_id=provided_id,
             artifact=artifact,
             # We should check with fern if we could auto-serialize typed object fields for us
             # https://app.shortcut.com/vellum/story/5568
             deployment_config=deployment_config_serialized,  # type: ignore[arg-type]
+            dataset=dataset_serialized,  # type: ignore[arg-type]
             dry_run=dry_run,
             strict=strict,
         )

vellum_cli/tests/conftest.py

@@ -1,8 +1,6 @@
 import pytest
 from dataclasses import dataclass
-import os
-import shutil
-import tempfile
+import pathlib
 from uuid import uuid4
 from typing import Any, Callable, Dict, Generator
 
@@ -18,17 +16,17 @@ class MockModuleResult:
 
 
 @pytest.fixture
-def mock_module(request) -> Generator[MockModuleResult, None, None]:
-    current_dir = os.getcwd()
-    temp_dir = tempfile.mkdtemp()
-    os.chdir(temp_dir)
+def mock_module(
+    request, monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> Generator[MockModuleResult, None, None]:
+    monkeypatch.chdir(tmp_path)
 
     # Use the test name to create a unique module path
     module = f"examples.mock.{request.node.name}"
     workflow_sandbox_id = str(uuid4())
 
     def set_pyproject_toml(vellum_config: Dict[str, Any]) -> None:
-        pyproject_toml_path = os.path.join(temp_dir, "pyproject.toml")
+        pyproject_toml_path = tmp_path / "pyproject.toml"
         with open(pyproject_toml_path, "wb") as f:
             tomli_w.dump(
                 {"tool": {"vellum": vellum_config}},
@@ -46,19 +44,16 @@ def mock_module(request) -> Generator[MockModuleResult, None, None]:
         }
     )
 
-    with open(os.path.join(temp_dir, ".env"), "w") as f:
+    with open(tmp_path / ".env", "w") as f:
         f.write("VELLUM_API_KEY=abcdef123456")
 
     yield MockModuleResult(
-        temp_dir=temp_dir,
+        temp_dir=str(tmp_path),
         module=module,
         set_pyproject_toml=set_pyproject_toml,
         workflow_sandbox_id=workflow_sandbox_id,
     )
 
-    os.chdir(current_dir)
-    shutil.rmtree(temp_dir)
-
 
 @pytest.fixture
 def info_log_level(monkeypatch):

vellum_cli/tests/test_image_push.py

@@ -1,9 +1,8 @@
 import pytest
 import json
 import os
-import shutil
+import pathlib
 import subprocess
-import tempfile
 from unittest.mock import MagicMock
 from uuid import uuid4
 from typing import Generator
@@ -16,15 +15,9 @@ from vellum_cli import main as cli_main
 
 
 @pytest.fixture
-def mock_temp_dir() -> Generator[str, None, None]:
-    current_dir = os.getcwd()
-    temp_dir = tempfile.mkdtemp()
-    os.chdir(temp_dir)
-
-    yield temp_dir
-
-    os.chdir(current_dir)
-    shutil.rmtree(temp_dir)
+def mock_temp_dir(monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path) -> Generator[str, None, None]:
+    monkeypatch.chdir(tmp_path)
+    yield str(tmp_path)
 
 
 @pytest.fixture

vellum_cli/tests/test_pull.py

@@ -1,7 +1,7 @@
 import pytest
 import json
 import os
-import tempfile
+import pathlib
 from unittest import mock
 from uuid import uuid4
 
@@ -227,7 +227,7 @@ def test_pull__with_nested_target_dir(vellum_client, mock_module, base_command):
         }
 
 
-def test_pull__sandbox_id_with_no_config(vellum_client):
+def test_pull__sandbox_id_with_no_config(vellum_client, monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path):
     # GIVEN a workflow sandbox id
     workflow_sandbox_id = "87654321-0000-0000-0000-000000000000"
 
@@ -237,28 +237,25 @@ def test_pull__sandbox_id_with_no_config(vellum_client):
     )
 
     # AND we are currently in a new directory
-    current_dir = os.getcwd()
-    temp_dir = tempfile.mkdtemp()
-    os.chdir(temp_dir)
+    monkeypatch.chdir(tmp_path)
 
     # WHEN the user runs the pull command with the workflow sandbox id and no module
     runner = CliRunner()
     result = runner.invoke(cli_main, ["workflows", "pull", "--workflow-sandbox-id", workflow_sandbox_id])
-    os.chdir(current_dir)
 
     # THEN the command returns successfully
     assert result.exit_code == 0
 
     # AND the pull api is called with the workflow sandbox id
     vellum_client.workflows.pull.assert_called_once()
-    workflow_py = os.path.join(temp_dir, "super_cool_workflow", "workflow.py")
-    assert os.path.exists(workflow_py)
+    workflow_py = tmp_path / "super_cool_workflow" / "workflow.py"
+    assert workflow_py.exists()
     with open(workflow_py) as f:
         assert f.read() == "print('hello')"
 
     # AND the vellum.lock.json file is created
-    vellum_lock_json = os.path.join(temp_dir, "vellum.lock.json")
-    assert os.path.exists(vellum_lock_json)
+    vellum_lock_json = tmp_path / "vellum.lock.json"
+    assert vellum_lock_json.exists()
     with open(vellum_lock_json) as f:
         lock_data = json.loads(f.read())
         assert lock_data == {
@@ -310,7 +307,9 @@ def test_pull__sandbox_id_with_other_workflow_configured(vellum_client, mock_mod
         assert f.read() == "print('hello')"
 
 
-def test_pull__workflow_deployment_with_no_config(vellum_client):
+def test_pull__workflow_deployment_with_no_config(
+    vellum_client, monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+):
     # GIVEN a workflow deployment
     workflow_deployment = "my-deployment"
     deployment_id = str(uuid4())
@@ -330,28 +329,25 @@ def test_pull__workflow_deployment_with_no_config(vellum_client):
     )
 
     # AND we are currently in a new directory
-    current_dir = os.getcwd()
-    temp_dir = tempfile.mkdtemp()
-    os.chdir(temp_dir)
+    monkeypatch.chdir(tmp_path)
 
     # WHEN the user runs the pull command with the workflow deployment
     runner = CliRunner()
     result = runner.invoke(cli_main, ["workflows", "pull", "--workflow-deployment", workflow_deployment])
-    os.chdir(current_dir)
 
     # THEN the command returns successfully
     assert result.exit_code == 0
 
     # AND the pull api is called with the workflow deployment
     vellum_client.workflows.pull.assert_called_once()
-    workflow_py = os.path.join(temp_dir, "my_deployment", "workflow.py")
-    assert os.path.exists(workflow_py)
+    workflow_py = tmp_path / "my_deployment" / "workflow.py"
+    assert workflow_py.exists()
     with open(workflow_py) as f:
         assert f.read() == "print('hello')"
 
     # AND the vellum.lock.json file is created
-    vellum_lock_json = os.path.join(temp_dir, "vellum.lock.json")
-    assert os.path.exists(vellum_lock_json)
+    vellum_lock_json = tmp_path / "vellum.lock.json"
+    assert vellum_lock_json.exists()
     with open(vellum_lock_json) as f:
         lock_data = json.loads(f.read())
         assert lock_data == {
@@ -381,7 +377,9 @@ def test_pull__workflow_deployment_with_no_config(vellum_client):
         }
 
 
-def test_pull__both_workflow_sandbox_id_and_deployment(vellum_client):
+def test_pull__both_workflow_sandbox_id_and_deployment(
+    vellum_client, monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+):
     # GIVEN a workflow sandbox id
     workflow_sandbox_id = "87654321-0000-0000-0000-000000000000"
 
@@ -392,9 +390,7 @@ def test_pull__both_workflow_sandbox_id_and_deployment(vellum_client):
     vellum_client.workflows.pull.return_value = iter([zip_file_map({"workflow.py": "print('hello')"})])
 
     # AND we are currently in a new directory
-    current_dir = os.getcwd()
-    temp_dir = tempfile.mkdtemp()
-    os.chdir(temp_dir)
+    monkeypatch.chdir(tmp_path)
 
     # WHEN the user runs the pull command with the workflow deployment
     runner = CliRunner()
@@ -409,7 +405,6 @@ def test_pull__both_workflow_sandbox_id_and_deployment(vellum_client):
             workflow_deployment,
         ],
     )
-    os.chdir(current_dir)
 
     # THEN the command returns successfully
     assert result.exit_code == 1
@@ -823,7 +818,7 @@ def test_pull__multiple_instances_of_same_module__keep_when_pulling_another_modu
         assert len(lock_data["workflows"]) == 3
 
 
-def test_pull__module_name_from_deployment_name(vellum_client):
+def test_pull__module_name_from_deployment_name(vellum_client, monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path):
     # GIVEN a workflow deployment
     workflow_deployment = "test-workflow-deployment-id"
 
@@ -840,29 +835,28 @@ def test_pull__module_name_from_deployment_name(vellum_client):
         ]
     )
 
-    # AND we are currently in a new directory
-    current_dir = os.getcwd()
-    temp_dir = tempfile.mkdtemp()
-    os.chdir(temp_dir)
+    # AND we are currently in a new directory with a .env file
+    monkeypatch.chdir(tmp_path)
+    with open(tmp_path / ".env", "w") as f:
+        f.write("VELLUM_API_KEY=test-api-key")
 
     # WHEN the user runs the pull command with the workflow deployment
     runner = CliRunner()
     result = runner.invoke(cli_main, ["workflows", "pull", "--workflow-deployment", workflow_deployment])
-    os.chdir(current_dir)
 
     # THEN the command returns successfully
     assert result.exit_code == 0
 
     # AND the module name is derived from the deployment_name in metadata.json (snake_cased)
-    vellum_lock_json = os.path.join(temp_dir, "vellum.lock.json")
-    assert os.path.exists(vellum_lock_json)
+    vellum_lock_json = tmp_path / "vellum.lock.json"
+    assert vellum_lock_json.exists()
     with open(vellum_lock_json) as f:
         lock_data = json.loads(f.read())
         assert lock_data["workflows"][0]["module"] == "test_deployment"
 
     # AND the workflow.py file is written to the module directory with the correct name
-    workflow_py = os.path.join(temp_dir, "test_deployment", "workflow.py")
-    assert os.path.exists(workflow_py)
+    workflow_py = tmp_path / "test_deployment" / "workflow.py"
+    assert workflow_py.exists()
     with open(workflow_py) as f:
         assert f.read() == "print('hello')"
 
@@ -958,10 +952,12 @@ def test_pull__unexpected_error_path(vellum_client):
     "workflow_deployment",
     [
         "test-workflow-deployment-id",
-        str(uuid4()),
+        "377a59fb-1dd0-4760-9568-ae4bd6188da0",
     ],
 )
-def test_pull__workflow_deployment_adds_deployment_to_config(vellum_client, workflow_deployment):
+def test_pull__workflow_deployment_adds_deployment_to_config(
+    vellum_client, workflow_deployment, monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+):
     # GIVEN a workflow deployment ID
     deployment_id = str(uuid4())  # config will always use the deployment_id return from the API
     deployment_name = "Test Deployment"
@@ -986,9 +982,8 @@ def test_pull__workflow_deployment_adds_deployment_to_config(vellum_client, work
     )
 
     # AND we are currently in a new directory
-    current_dir = os.getcwd()
-    temp_dir = tempfile.mkdtemp()
-    os.chdir(temp_dir)
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("VELLUM_API_KEY", "abcdef123456")
 
     # WHEN the user runs the pull command with the workflow deployment
     runner = CliRunner()
@@ -998,8 +993,8 @@ def test_pull__workflow_deployment_adds_deployment_to_config(vellum_client, work
     assert result.exit_code == 0
 
     # AND the deployment is saved in the config
-    vellum_lock_json = os.path.join(temp_dir, "vellum.lock.json")
-    assert os.path.exists(vellum_lock_json)
+    vellum_lock_json = tmp_path / "vellum.lock.json"
+    assert vellum_lock_json.exists()
     with open(vellum_lock_json) as f:
         lock_data = json.loads(f.read())
         assert len(lock_data["workflows"]) == 1
@@ -1009,21 +1004,18 @@ def test_pull__workflow_deployment_adds_deployment_to_config(vellum_client, work
         assert deployment["name"] == deployment_name
         assert deployment["label"] == deployment_label
 
-    os.chdir(current_dir)
-
 
-def test_pull__workflow_deployment_name_is_uuid(vellum_client):
+def test_pull__workflow_deployment_name_is_uuid(vellum_client, monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path):
     # GIVEN a workflow deployment name that is a valid UUID
     deployment_id = str(uuid4())
     deployment_name = str(uuid4())
 
     # AND an existing configuration with this deployment
-    current_dir = os.getcwd()
-    temp_dir = tempfile.mkdtemp()
-    os.chdir(temp_dir)
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("VELLUM_API_KEY", "abcdef123456")
 
     # Create initial config with a deployment
-    vellum_lock_json = os.path.join(temp_dir, "vellum.lock.json")
+    vellum_lock_json = tmp_path / "vellum.lock.json"
     with open(vellum_lock_json, "w") as f:
         json.dump(
             {
@@ -1089,11 +1081,11 @@ def test_pull__workflow_deployment_name_is_uuid(vellum_client):
         assert deployment["name"] == deployment_name
         assert deployment["label"] == updated_label
 
-    os.chdir(current_dir)
-
 
 @pytest.mark.parametrize("get_identifier", [(lambda d: d), (lambda d: "Test Name")])
-def test_pull__workflow_deployment_updates_existing_deployment(vellum_client, get_identifier):
+def test_pull__workflow_deployment_updates_existing_deployment(
+    vellum_client, get_identifier, monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+):
     """
     This test is to ensure that the deployment info is updated in the config
     when the user runs the pull command with the workflow deployment
@@ -1106,12 +1098,11 @@ def test_pull__workflow_deployment_updates_existing_deployment(vellum_client, ge
     deployment_name = "Test Name"
 
     # AND an existing configuration with this deployment
-    current_dir = os.getcwd()
-    temp_dir = tempfile.mkdtemp()
-    os.chdir(temp_dir)
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("VELLUM_API_KEY", "abcdef123456")
 
     # Create initial config with a deployment
-    vellum_lock_json = os.path.join(temp_dir, "vellum.lock.json")
+    vellum_lock_json = tmp_path / "vellum.lock.json"
     with open(vellum_lock_json, "w") as f:
         json.dump(
             {
@@ -1178,10 +1169,10 @@ def test_pull__workflow_deployment_updates_existing_deployment(vellum_client, ge
         assert deployment["name"] == deployment_name
         assert deployment["label"] == updated_label
 
-    os.chdir(current_dir)
-
 
-def test_pull__workflow_deployment_with_name_and_id(vellum_client):
+def test_pull__workflow_deployment_with_name_and_id(
+    vellum_client, monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+):
     """
     This test is to ensure that pulling with id and name will not add a new deployment to the config
     """
@@ -1210,9 +1201,8 @@ def test_pull__workflow_deployment_with_name_and_id(vellum_client):
     )
 
     # AND we are currently in a new directory
-    current_dir = os.getcwd()
-    temp_dir = tempfile.mkdtemp()
-    os.chdir(temp_dir)
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("VELLUM_API_KEY", "abcdef123456")
 
     # WHEN the user runs the pull command with the workflow deployment
     runner = CliRunner()
@@ -1222,8 +1212,8 @@ def test_pull__workflow_deployment_with_name_and_id(vellum_client):
     assert result.exit_code == 0
 
     # AND the deployment is saved in the config
-    vellum_lock_json = os.path.join(temp_dir, "vellum.lock.json")
-    assert os.path.exists(vellum_lock_json)
+    vellum_lock_json = tmp_path / "vellum.lock.json"
+    assert vellum_lock_json.exists()
     with open(vellum_lock_json) as f:
         lock_data = json.loads(f.read())
         assert len(lock_data["workflows"]) == 1
@@ -1234,8 +1224,6 @@ def test_pull__workflow_deployment_with_name_and_id(vellum_client):
         assert deployment["label"] == deployment_label
         assert lock_data["workflows"][0]["workflow_sandbox_id"] == workflow_sandbox_id
 
-    os.chdir(current_dir)
-
     # AND pull with name will not add a new deployment to the config
     vellum_client.workflows.pull.return_value = iter(
         [
@@ -1254,7 +1242,6 @@ def test_pull__workflow_deployment_with_name_and_id(vellum_client):
         ]
     )
 
-    os.chdir(temp_dir)
     result = runner.invoke(cli_main, ["workflows", "pull", "--workflow-deployment", deployment_name])
     assert result.exit_code == 0
     with open(vellum_lock_json) as f:
@@ -1264,8 +1251,6 @@ def test_pull__workflow_deployment_with_name_and_id(vellum_client):
         assert lock_data["workflows"][0]["deployments"][0]["name"] == deployment_name
         assert lock_data["workflows"][0]["deployments"][0]["label"] == deployment_label
 
-    os.chdir(current_dir)
-
 
 def test_pull__workspace_option__uses_different_api_key(mock_module, vellum_client_class):
     # GIVEN a module and workflow_sandbox_id
@@ -1337,3 +1322,33 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
     assert os.path.exists(workflow_py)
     with open(workflow_py) as f:
         assert f.read() == "print('hello')"
+
+
+@pytest.mark.parametrize(
+    "base_command",
+    [
+        ["pull"],
+        ["workflows", "pull"],
+    ],
+    ids=["pull", "workflows_pull"],
+)
+def test_pull__release_tag(vellum_client, mock_module, base_command):
+    """Tests that the --release-tag option is passed to the API."""
+
+    # GIVEN a module on the user's filesystem
+    module = mock_module.module
+
+    # AND the workflow pull API call returns a zip file
+    vellum_client.workflows.pull.return_value = iter([zip_file_map({"workflow.py": "print('hello')"})])
+
+    # WHEN the user runs the pull command with --release-tag
+    runner = CliRunner()
+    result = runner.invoke(cli_main, base_command + [module, "--release-tag", "my-release-tag"])
+
+    # THEN the command returns successfully
+    assert result.exit_code == 0
+
+    # AND the pull api is called with release_tag="my-release-tag"
+    vellum_client.workflows.pull.assert_called_once()
+    call_args = vellum_client.workflows.pull.call_args.kwargs
+    assert call_args["release_tag"] == "my-release-tag"