skypilot-nightly 1.0.0.dev20251210__py3-none-any.whl → 1.0.0.dev20260112__py3-none-any.whl

sky/utils/interactive_utils.py

@@ -0,0 +1,49 @@
+"""Utilities for server-side interactive SSH functionality."""
+import array
+import socket
+
+
+def get_pty_socket_path(session_id: str) -> str:
+    """Get the Unix socket path for PTY file descriptor passing."""
+    return f'/tmp/sky_pty_{session_id}.sock'
+
+
+def send_fd(sock: socket.socket, fd: int) -> None:
+    """Send file descriptor via Unix socket using SCM_RIGHTS.
+
+    SCM_RIGHTS allows us to send or receive a set of open
+    file descriptors from another process.
+
+    See:
+    https://man7.org/linux/man-pages/man7/unix.7.html
+    https://man7.org/linux/man-pages/man3/cmsg.3.html
+
+    Args:
+        sock: Connected Unix socket.
+        fd: File descriptor to send.
+    """
+    sock.sendmsg(
+        [b'x'],  # Dummy data
+        [(socket.SOL_SOCKET, socket.SCM_RIGHTS, array.array('i', [fd]))])
+
+
+def recv_fd(sock: socket.socket) -> int:
+    """Receive file descriptor via Unix socket using SCM_RIGHTS.
+
+    Args:
+        sock: Connected Unix socket.
+
+    Returns:
+        Received file descriptor.
+
+    Raises:
+        RuntimeError: If no file descriptor was received.
+    """
+    # NOTE: recvmsg() has no async equivalent
+    _, ancdata, _, _ = sock.recvmsg(
+        1, socket.CMSG_SPACE(array.array('i', [0]).itemsize))
+    if not ancdata:
+        raise RuntimeError('No file descriptor received - '
+                           'sender may have closed connection')
+    _, _, cmsg_data = ancdata[0]
+    return array.array('i', cmsg_data)[0]

sky/utils/kubernetes/generate_kubeconfig.sh

@@ -12,20 +12,20 @@
 #   * Specify SKYPILOT_NAMESPACE env var to override the default namespace where the service account is created.
 #   * Specify SKYPILOT_SA_NAME env var to override the default service account name.
 #   * Specify SKIP_SA_CREATION=1 to skip creating the service account and use an existing one
-#   * Specify SUPER_USER=1 to create a service account with cluster-admin permissions
+#   * Specify SUPER_USER=0 to create a service account with minimal permissions
 #
 # Usage:
-#   # Create "sky-sa" service account with minimal permissions in "default" namespace and generate kubeconfig
+#   # Create "sky-sa" service account in "default" namespace and generate kubeconfig
 #   $ ./generate_kubeconfig.sh
 #
-#   # Create "my-sa" service account with minimal permissions in "my-namespace" namespace and generate kubeconfig
+#   # Create "my-sa" service account in "my-namespace" namespace and generate kubeconfig
 #   $ SKYPILOT_SA_NAME=my-sa SKYPILOT_NAMESPACE=my-namespace ./generate_kubeconfig.sh
 #
 #   # Use an existing service account "my-sa" in "my-namespace" namespace and generate kubeconfig
 #   $ SKIP_SA_CREATION=1 SKYPILOT_SA_NAME=my-sa SKYPILOT_NAMESPACE=my-namespace ./generate_kubeconfig.sh
 #
-#   # Create "sky-sa" service account with cluster-admin permissions in "default" namespace
-#   $ SUPER_USER=1 ./generate_kubeconfig.sh
+#   # Create "sky-sa" service account with minimal permissions in "default" namespace (manual setup may be required)
+#   $ SUPER_USER=0 ./generate_kubeconfig.sh
 
 set -eu -o pipefail
 
@@ -33,11 +33,18 @@ set -eu -o pipefail
 # use default.
 SKYPILOT_SA=${SKYPILOT_SA_NAME:-sky-sa}
 NAMESPACE=${SKYPILOT_NAMESPACE:-default}
-SUPER_USER=${SUPER_USER:-0}
+SUPER_USER=${SUPER_USER:-1}
 
-echo "Service account: ${SKYPILOT_SA}"
-echo "Namespace: ${NAMESPACE}"
-echo "Super user permissions: ${SUPER_USER}"
+echo "=========================================="
+echo "SkyPilot Kubeconfig Generation"
+echo "=========================================="
+echo "Service Account: ${SKYPILOT_SA}"
+echo "Namespace:       ${NAMESPACE}"
+if [ "${SUPER_USER}" != "1" ]; then
+  echo "Permissions:     Minimal (manual setup may be required)"
+  SUPER_USER=0
+fi
+echo ""
 
 # Set OS specific values.
 if [[ "$OSTYPE" == "linux-gnu" ]]; then
@@ -53,7 +60,7 @@ fi
 
 # If the user has set SKIP_SA_CREATION=1, skip creating the service account.
 if [ -z ${SKIP_SA_CREATION+x} ]; then
-  echo "Creating the Kubernetes Service Account with ${SUPER_USER:+super user}${SUPER_USER:-minimal} RBAC permissions."
+  echo "[1/3] Creating Kubernetes Service Account and RBAC permissions..."
   if [ "${SUPER_USER}" = "1" ]; then
     # Create service account with cluster-admin permissions
     kubectl apply -f - <<EOF
@@ -219,7 +226,8 @@ roleRef:
 EOF
   fi
 # Apply optional ingress-related roles, but don't make the script fail if it fails
-kubectl apply -f - <<EOF || echo "Failed to apply optional ingress-related roles. Nginx ingress is likely not installed. This is not critical and the script will continue."
+echo "      → Applying optional ingress permissions (skipped if ingress-nginx not installed)..."
+kubectl apply -f - 2>/dev/null <<EOF || true
 # Optional: Role for accessing ingress resources
 apiVersion: rbac.authorization.k8s.io/v1
 kind: Role
@@ -253,8 +261,13 @@ roleRef:
   name: ${SKYPILOT_SA}-role-ingress-nginx  # Use the same name as the role at line 119
   apiGroup: rbac.authorization.k8s.io
 EOF
+else
+  echo "[1/3] Skipping service account creation (using existing account)..."
 fi
 
+echo ""
+echo "[2/3] Creating service account token..."
+
 # Checks if secret entry was defined for Service account. If defined it means that Kubernetes server has a
 # version bellow 1.24, otherwise one must manually create the secret and bind it to the Service account to have a non expiring token.
 # After Kubernetes v1.24 Service accounts no longer generate automatic tokens/secrets.
@@ -293,7 +306,9 @@ CURRENT_CONTEXT=$(kubectl config current-context)
 CURRENT_CLUSTER=$(kubectl config view -o jsonpath="{.contexts[?(@.name == \"${CURRENT_CONTEXT}\"})].context.cluster}")
 CURRENT_CLUSTER_ADDR=$(kubectl config view -o jsonpath="{.clusters[?(@.name == \"${CURRENT_CLUSTER}\"})].cluster.server}")
 
-echo "Writing kubeconfig."
+echo ""
+echo "[3/3] Generating kubeconfig file..."
+
 cat > kubeconfig <<EOF
 apiVersion: v1
 clusters:
@@ -316,24 +331,18 @@ users:
     token: ${SA_TOKEN}
 EOF
 
-echo "---
-Done!
-
-Kubeconfig using service account '${SKYPILOT_SA}' in namespace '${NAMESPACE}' written at $(pwd)/kubeconfig
-
-Copy the generated kubeconfig file to your ~/.kube/ directory to use it with
-kubectl and skypilot:
-
-# Backup your existing kubeconfig file
-mv ~/.kube/config ~/.kube/config.bak
-cp kubeconfig ~/.kube/config
-
-# Verify that you can access the cluster
-kubectl get pods
-
-Also add this to your ~/.sky/config.yaml to use the new service account:
-
-# ~/.sky/config.yaml
-kubernetes:
-  remote_identity: ${SKYPILOT_SA}
-"
+echo ""
+echo "=========================================="
+echo "✓ SUCCESS!"
+echo "=========================================="
+echo ""
+echo "Kubeconfig file created successfully!"
+echo ""
+echo "  Service Account: ${SKYPILOT_SA}"
+echo "  Namespace:       ${NAMESPACE}"
+echo "  Location:        $(pwd)/kubeconfig"
+echo ""
+echo "Next steps:"
+echo "  Refer to this page for setting up the credential for remote API server:"
+echo "  https://docs.skypilot.co/en/latest/reference/api-server/api-server-admin-deploy.html#optional-configure-cloud-accounts"
+echo ""

sky/utils/kubernetes/rsync_helper.sh

@@ -60,4 +60,8 @@ fi
 # We wrap the command in a bash script that waits for rsync, then execs the original command.
 # Timeout after MAX_WAIT_TIME_SECONDS seconds.
 MAX_WAIT_TIME_SECONDS=300
-eval "${kubectl_cmd_base% --} -i -- bash -c 'count=0; max_count=$MAX_WAIT_TIME_SECONDS*2; until which rsync >/dev/null 2>&1; do if [ \$count -ge \$max_count ]; then echo \"Error when trying to rsync files to kubernetes cluster. Package installation may have failed.\" >&2; exit 1; fi; sleep 0.5; count=\$((count+1)); done; exec \"\$@\"' -- \"\$@\""
+MAX_WAIT_COUNT=$((MAX_WAIT_TIME_SECONDS * 2))
+# Use --norc --noprofile to prevent bash from sourcing startup files that might
+# output to stdout and corrupt the rsync protocol. All debug output must go to
+# stderr (>&2) to keep stdout clean for rsync communication.
+eval "${kubectl_cmd_base% --} -i -- bash --norc --noprofile -c 'count=0; until which rsync >/dev/null 2>&1; do if [ \$count -ge $MAX_WAIT_COUNT ]; then echo \"Error when trying to rsync files to kubernetes cluster. Package installation may have failed.\" >&2; exit 1; fi; sleep 0.5; count=\$((count+1)); done; exec \"\$@\"' -- \"\$@\""

sky/utils/plugin_extensions/__init__.py

@@ -0,0 +1,14 @@
+"""Plugin extensions module.
+
+This module provides extension points that plugins can hook into to provide
+custom functionality.
+"""
+from sky.utils.plugin_extensions.external_failure_source import (
+    ExternalClusterFailure)
+from sky.utils.plugin_extensions.external_failure_source import (
+    ExternalFailureSource)
+
+__all__ = [
+    'ExternalClusterFailure',
+    'ExternalFailureSource',
+]

sky/utils/plugin_extensions/external_failure_source.py

@@ -0,0 +1,176 @@
+"""External failure source interface for plugins.
+
+This module provides an extension point that allows plugins to provide
+cluster failure tracking functionality. By default, no-op implementations
+are used. Plugins can register their own implementations to provide actual
+failure tracking.
+
+Example usage in a plugin:
+    from sky.utils.plugin_extensions import ExternalFailureSource
+
+    # Register custom failure source
+    ExternalFailureSource.register(
+        get_failures=my_get_cluster_failures,
+        clear_failures=my_clear_cluster_failures,
+    )
+
+Example usage in core SkyPilot:
+    from sky.utils.plugin_extensions import ExternalFailureSource
+
+    # Get failures for a cluster
+    failures = ExternalFailureSource.get(cluster_hash='abc123')
+
+    # Clear failures for a cluster
+    cleared = ExternalFailureSource.clear(cluster_name='my-cluster')
+"""
+import dataclasses
+from typing import Any, Dict, List, Optional, Protocol
+
+from sky import sky_logging
+
+logger = sky_logging.init_logger(__name__)
+
+
+@dataclasses.dataclass
+class ExternalClusterFailure:
+    """Represents a single cluster failure from an external source.
+
+    Attributes:
+        code: Machine-readable failure code (e.g. 'GPU_HARDWARE_FAILURE_XID_79')
+        reason: Human-readable description of the failure.
+    """
+    code: str
+    reason: str
+
+    @classmethod
+    def from_failure_list(
+            cls, failures: List[Dict[str,
+                                     Any]]) -> List['ExternalClusterFailure']:
+        """Create a list of ExternalClusterFailure from failure dicts.
+
+        Args:
+            failures: List of dicts with 'failure_mode' and 'failure_reason'
+                keys (as returned by ExternalFailureSource.get()).
+
+        Returns:
+            List of ExternalClusterFailure objects, one per failure.
+        """
+        return [
+            cls(code=f['failure_mode'], reason=f['failure_reason'])
+            for f in failures
+        ]
+
+
+# Protocol definitions for the failure source functions
+class GetClusterFailuresFunc(Protocol):
+    """Protocol for get_cluster_failures function."""
+
+    def __call__(self,
+                 cluster_hash: Optional[str] = None,
+                 cluster_name: Optional[str] = None) -> List[Dict[str, Any]]:
+        ...
+
+
+class ClearClusterFailuresFunc(Protocol):
+    """Protocol for clear_cluster_failures function."""
+
+    def __call__(self,
+                 cluster_hash: Optional[str] = None,
+                 cluster_name: Optional[str] = None) -> List[Dict[str, Any]]:
+        ...
+
+
+class ExternalFailureSource:
+    """Singleton class for external cluster failure source.
+
+    This class provides an extension point for plugins to register their own
+    cluster failure tracking implementations. By default, no-op implementations
+    are used that return empty lists.
+
+    Plugins can register their implementations during their install() phase,
+    and core SkyPilot code can use the get() and clear() methods to interact
+    with cluster failures without knowing which plugin (if any) is providing
+    the implementation.
+    """
+
+    _get_func: Optional[GetClusterFailuresFunc] = None
+    _clear_func: Optional[ClearClusterFailuresFunc] = None
+
+    @classmethod
+    def register(cls, get_failures: GetClusterFailuresFunc,
+                 clear_failures: ClearClusterFailuresFunc) -> None:
+        """Register an external failure source implementation.
+
+        This allows plugins to provide their own cluster failure tracking.
+        Only one external failure source can be registered at a time.
+
+        Args:
+            get_failures: Function to get active cluster failures.
+                Signature: (cluster_hash: Optional[str],
+                            cluster_name: Optional[str])
+                           -> List[Dict[str, Any]]
+                Returns list of dicts with keys: cluster_hash, failure_mode,
+                failure_reason, cleared_at.
+            clear_failures: Function to clear cluster failures.
+                Signature: (cluster_hash: Optional[str],
+                            cluster_name: Optional[str])
+                           -> List[Dict[str, Any]]
+                Returns list of dicts of the failures that were cleared.
+        """
+        cls._get_func = get_failures
+        cls._clear_func = clear_failures
+        logger.info('Registered external failure source')
+
+    @classmethod
+    def is_registered(cls) -> bool:
+        """Check if an external failure source is registered."""
+        return cls._get_func is not None and cls._clear_func is not None
+
+    @classmethod
+    def get(cls,
+            cluster_hash: Optional[str] = None,
+            cluster_name: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Get active cluster failures from the registered failure source.
+
+        Args:
+            cluster_hash: Hash of the cluster to query failures for.
+            cluster_name: Name of the cluster to query failures for.
+
+        Returns:
+            List of dictionaries containing failure records.
+            Each dict contains: cluster_hash, failure_mode, failure_reason,
+            cleared_at. Returns empty list if no failure source is registered.
+        """
+        if cls._get_func is None:
+            return []
+        try:
+            # pylint: disable=not-callable
+            return cls._get_func(cluster_name=cluster_name,
+                                 cluster_hash=cluster_hash)
+        except Exception as e:  # pylint: disable=broad-except
+            logger.warning(f'Failed to get cluster failures: {e}')
+            return []
+
+    @classmethod
+    def clear(cls,
+              cluster_hash: Optional[str] = None,
+              cluster_name: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Clear cluster failures via the registered failure source.
+
+        Args:
+            cluster_hash: Hash of the cluster to clear failures for.
+            cluster_name: Name of the cluster to clear failures for.
+
+        Returns:
+            List of dictionaries containing the failure records that were
+            cleared. Returns empty list if no failure source is registered.
+        """
+        if cls._clear_func is None:
+            return []
+        try:
+            # pylint: disable=not-callable
+            return cls._clear_func(cluster_name=cluster_name,
+                                   cluster_hash=cluster_hash)
+        except Exception as e:  # pylint: disable=broad-except
+            logger.warning(f'Failed to clear cluster failures: {e}')
+            return []

sky/utils/resources_utils.py

@@ -183,7 +183,8 @@ def simplify_ports(ports: List[str]) -> List[str]:
 def format_resource(resource: 'resources_lib.Resources',
                     simplified_only: bool = False) -> Tuple[str, Optional[str]]:
     resource = resource.assert_launchable()
-    is_k8s = str(resource.cloud).lower() == 'kubernetes'
+    is_k8s = resource.cloud.canonical_name() == 'kubernetes'
+    vcpu, mem = None, None
     if resource.accelerators is None or is_k8s or not simplified_only:
         vcpu, mem = resource.cloud.get_vcpus_mem_from_instance_type(
             resource.instance_type)
@@ -198,18 +199,19 @@ def format_resource(resource: 'resources_lib.Resources',
 
     if (resource.accelerators is None or is_k8s):
         if vcpu is not None:
-            elements_simple.append(f'cpus={int(vcpu)}')
-            elements_full.append(f'cpus={int(vcpu)}')
+            elements_simple.append(f'cpus={common_utils.format_float(vcpu)}')
+            elements_full.append(f'cpus={common_utils.format_float(vcpu)}')
         if mem is not None:
-            elements_simple.append(f'mem={int(mem)}')
-            elements_full.append(f'mem={int(mem)}')
+            elements_simple.append(f'mem={common_utils.format_float(mem)}')
+            elements_full.append(f'mem={common_utils.format_float(mem)}')
     elif not simplified_only:
         if vcpu is not None:
-            elements_full.append(f'cpus={int(vcpu)}')
+            elements_full.append(f'cpus={common_utils.format_float(vcpu)}')
         if mem is not None:
-            elements_full.append(f'mem={int(mem)}')
+            elements_full.append(f'mem={common_utils.format_float(mem)}')
 
-    if not is_k8s:
+    is_slurm = resource.cloud.canonical_name() == 'slurm'
+    if not is_k8s and not is_slurm:
         instance_type_full = resource.instance_type
         instance_type_simple = common_utils.truncate_long_string(
             instance_type_full, 15)

sky/utils/rich_utils.py

@@ -362,14 +362,14 @@ def decode_rich_status(
                     # Replace `\r\n` with `\n`, as printing a line ends with
                     # `\r\n` in linux will cause the line to be empty.
                     line = line[:-2] + '\n'
-                is_payload, line = message_utils.decode_payload(
+                is_payload, decoded_line = message_utils.decode_payload(
                     line, raise_for_mismatch=False)
-                control = None
-                if is_payload:
-                    control, encoded_status = Control.decode(line)
-                if control is None:
+                if not is_payload:
                     yield line
                     continue
+                control, encoded_status = Control.decode(decoded_line)
+                if control is None:
+                    continue
 
                 if control == Control.RETRY:
                     raise exceptions.RequestInterruptedError(
@@ -481,15 +481,13 @@ async def decode_rich_status_async(
                     # Replace `\r\n` with `\n`, as printing a line ends with
                     # `\r\n` in linux will cause the line to be empty.
                     line = line[:-2] + '\n'
-                is_payload, line = message_utils.decode_payload(
+                is_payload, decoded_line = message_utils.decode_payload(
                     line, raise_for_mismatch=False)
-                if line is None:
+                if not is_payload:
+                    yield line
                     continue
-                control = None
-                if is_payload:
-                    control, encoded_status = Control.decode(line)
+                control, encoded_status = Control.decode(decoded_line)
                 if control is None:
-                    yield line
                     continue
 
                 if control == Control.RETRY:

sky/utils/schemas.py

@@ -208,26 +208,49 @@ def _get_single_resources_schema():
             },
             'job_recovery': {
                 # Either a string or a dict.
-                'anyOf': [{
-                    'type': 'string',
-                }, {
-                    'type': 'object',
-                    'required': [],
-                    'additionalProperties': False,
-                    'properties': {
-                        'strategy': {
-                            'anyOf': [{
-                                'type': 'string',
-                            }, {
-                                'type': 'null',
-                            }],
-                        },
-                        'max_restarts_on_errors': {
-                            'type': 'integer',
-                            'minimum': 0,
-                        },
+                'anyOf': [
+                    {
+                        'type': 'string',
+                    },
+                    {
+                        'type': 'object',
+                        'required': [],
+                        'additionalProperties': False,
+                        'properties': {
+                            'strategy': {
+                                'anyOf': [{
+                                    'type': 'string',
+                                }, {
+                                    'type': 'null',
+                                }],
+                            },
+                            'max_restarts_on_errors': {
+                                'type': 'integer',
+                                'minimum': 0,
+                            },
+                            'recover_on_exit_codes': {
+                                'anyOf': [
+                                    {
+                                        # Single exit code
+                                        'type': 'integer',
+                                        'minimum': 0,
+                                        'maximum': 255,
+                                    },
+                                    {
+                                        # List of exit codes
+                                        'type': 'array',
+                                        'items': {
+                                            'type': 'integer',
+                                            'minimum': 0,
+                                            'maximum': 255,
+                                        },
+                                        'uniqueItems': True,
+                                    },
+                                ],
+                            },
+                        }
                     }
-                }],
+                ],
             },
             'volumes': {
                 'type': 'array',
@@ -1461,7 +1484,7 @@ def get_config_schema():
             'required': [],
             'additionalProperties': False,
             'properties': {
-                'secure_only': {
+                'datacenter_only': {
                     'type': 'boolean',
                 },
             }
@@ -1845,6 +1868,25 @@ def get_config_schema():
             config['properties'].update(_REMOTE_IDENTITY_SCHEMA_KUBERNETES)
         else:
             config['properties'].update(_REMOTE_IDENTITY_SCHEMA)
+
+    data_schema = {
+        'type': 'object',
+        'required': [],
+        'additionalProperties': False,
+        'properties': {
+            'mount_cached': {
+                'type': 'object',
+                'required': [],
+                'additionalProperties': False,
+                'properties': {
+                    'sequential_upload': {
+                        'type': 'boolean',
+                    },
+                },
+            },
+        },
+    }
+
     return {
         '$schema': 'https://json-schema.org/draft/2020-12/schema',
         'type': 'object',
@@ -1871,6 +1913,7 @@ def get_config_schema():
             'rbac': rbac_schema,
             'logs': logs_schema,
             'daemons': daemon_schema,
+            'data': data_schema,
             **cloud_configs,
         },
     }

sky/utils/status_lib.py

@@ -27,6 +27,12 @@ class ClusterStatus(enum.Enum):
 
     STOPPED = 'STOPPED'
     """The cluster is stopped."""
+    PENDING = 'PENDING'
+    """The cluster is pending scheduling.
+
+    NOTE: This state is for display only and should not be used in state
+    machine logic without necessary considerations.
+    """
 
     def colored_str(self):
         color = _STATUS_TO_COLOR[self]
@@ -37,6 +43,7 @@ _STATUS_TO_COLOR = {
     ClusterStatus.INIT: colorama.Fore.BLUE,
     ClusterStatus.UP: colorama.Fore.GREEN,
     ClusterStatus.STOPPED: colorama.Fore.YELLOW,
+    ClusterStatus.PENDING: colorama.Fore.CYAN,
 }
 
 

sky/utils/subprocess_utils.py

@@ -7,6 +7,7 @@ import resource
 import shlex
 import subprocess
 import sys
+import termios
 import threading
 import time
 import typing
@@ -450,3 +451,19 @@ def slow_start_processes(processes: List[Startable],
             break
         batch_size = min(batch_size * 2, max_batch_size)
         time.sleep(delay)
+
+
+def is_echo_disabled(fd: int) -> bool:
+    """Check if terminal ECHO is disabled on the given fd.
+
+    When a subprocess wants password/sensitive input, it disables ECHO.
+    This is how pexpect's waitnoecho() works. See:
+    https://pexpect.readthedocs.io/en/stable/api/pexpect.html#pexpect.spawn.waitnoecho
+    """
+    assert os.isatty(fd), 'fd is not connected to a terminal'
+    try:
+        attr = termios.tcgetattr(fd)
+        echo_on = bool(attr[3] & termios.ECHO)
+        return not echo_on
+    except (termios.error, OSError):
+        return False

sky/volumes/client/sdk.py

@@ -1,4 +1,4 @@
-"""SDK functions for managed jobs."""
+"""SDK functions for volumes."""
 import json
 import typing
 from typing import List
@@ -135,16 +135,19 @@ def ls() -> server_common.RequestId[List[responses.VolumeRecord]]:
 @usage_lib.entrypoint
 @server_common.check_server_healthy_or_start
 @annotations.client_api
-def delete(names: List[str]) -> server_common.RequestId[None]:
+def delete(names: List[str],
+           purge: bool = False) -> server_common.RequestId[None]:
     """Deletes volumes.
 
     Args:
         names: List of volume names to delete.
+        purge: If True, delete the volume from the database even if the
+          deletion API fails.
 
     Returns:
         The request ID of the delete request.
     """
-    body = payloads.VolumeDeleteBody(names=names)
+    body = payloads.VolumeDeleteBody(names=names, purge=purge)
     response = server_common.make_authenticated_request(
         'POST', '/volumes/delete', json=json.loads(body.model_dump_json()))
     return server_common.get_request_id(response)