skypilot-nightly 1.0.0.dev20250927__py3-none-any.whl → 1.0.0.dev20251002__py3-none-any.whl

sky/__init__.py

@@ -7,7 +7,7 @@ import urllib.request
 from sky.utils import directory_utils
 
 # Replaced with the current commit when building the wheels.
-_SKYPILOT_COMMIT_SHA = 'e42224b6d29bd960c0e0daa69add0fe2ad695142'
+_SKYPILOT_COMMIT_SHA = 'e92268dca4331cab08759798deab9265e753cba8'
 
 
 def _get_git_commit():
@@ -37,7 +37,7 @@ def _get_git_commit():
 
 
 __commit__ = _get_git_commit()
-__version__ = '1.0.0.dev20250927'
+__version__ = '1.0.0.dev20251002'
 __root_dir__ = directory_utils.get_sky_dir()
 
 

sky/backends/backend_utils.py

@@ -723,11 +723,15 @@ def write_cluster_config(
                 'is not supported by this cloud. Remove the config or set: '
                 '`remote_identity: LOCAL_CREDENTIALS`.')
         if isinstance(cloud, clouds.Kubernetes):
-            if skypilot_config.get_effective_region_config(
+            allowed_contexts = skypilot_config.get_workspace_cloud(
+                'kubernetes').get('allowed_contexts', None)
+            if allowed_contexts is None:
+                allowed_contexts = skypilot_config.get_effective_region_config(
                     cloud='kubernetes',
                     region=None,
                     keys=('allowed_contexts',),
-                    default_value=None) is None:
+                    default_value=None)
+            if allowed_contexts is None:
                 excluded_clouds.add(cloud)
         else:
             excluded_clouds.add(cloud)
@@ -2613,7 +2617,7 @@ def refresh_cluster_record(
         cluster_name: str,
         *,
         force_refresh_statuses: Optional[Set[status_lib.ClusterStatus]] = None,
-        acquire_per_cluster_status_lock: bool = True,
+        cluster_lock_already_held: bool = False,
         cluster_status_lock_timeout: int = CLUSTER_STATUS_LOCK_TIMEOUT_SECONDS,
         include_user_info: bool = True,
         summary_response: bool = False) -> Optional[Dict[str, Any]]:
@@ -2633,9 +2637,13 @@ def refresh_cluster_record(
               _CLUSTER_STATUS_CACHE_DURATION_SECONDS old, and one of:
                 1. the cluster is a spot cluster, or
                 2. cluster autostop is set and the cluster is not STOPPED.
-        acquire_per_cluster_status_lock: Whether to acquire the per-cluster lock
-          before updating the status. Even if this is True, the lock may not be
-          acquired if the status does not need to be refreshed.
+        cluster_lock_already_held: Whether the caller is already holding the
+          per-cluster lock. You MUST NOT set this to True if the caller does not
+          already hold the lock. If True, we will not acquire the lock before
+          updating the status. Failing to hold the lock while updating the
+          status can lead to correctness issues - e.g. an launch in-progress may
+          appear to be DOWN incorrectly. Even if this is set to False, the lock
+          may not be acquired if the status does not need to be refreshed.
         cluster_status_lock_timeout: The timeout to acquire the per-cluster
           lock. If timeout, the function will use the cached status. If the
           value is <0, do not timeout (wait for the lock indefinitely). By
@@ -2686,7 +2694,7 @@ def refresh_cluster_record(
             if not _must_refresh_cluster_status(record, force_refresh_statuses):
                 return record
 
-            if not acquire_per_cluster_status_lock:
+            if cluster_lock_already_held:
                 return _update_cluster_status(cluster_name, include_user_info,
                                               summary_response)
 
@@ -2740,7 +2748,7 @@ def refresh_cluster_status_handle(
     cluster_name: str,
     *,
     force_refresh_statuses: Optional[Set[status_lib.ClusterStatus]] = None,
-    acquire_per_cluster_status_lock: bool = True,
+    cluster_lock_already_held: bool = False,
     cluster_status_lock_timeout: int = CLUSTER_STATUS_LOCK_TIMEOUT_SECONDS
 ) -> Tuple[Optional[status_lib.ClusterStatus],
            Optional[backends.ResourceHandle]]:
@@ -2753,7 +2761,7 @@ def refresh_cluster_status_handle(
     record = refresh_cluster_record(
         cluster_name,
         force_refresh_statuses=force_refresh_statuses,
-        acquire_per_cluster_status_lock=acquire_per_cluster_status_lock,
+        cluster_lock_already_held=cluster_lock_already_held,
         cluster_status_lock_timeout=cluster_status_lock_timeout,
         include_user_info=False,
         summary_response=True)
@@ -3078,7 +3086,7 @@ def _refresh_cluster(
         record = refresh_cluster_record(
             cluster_name,
             force_refresh_statuses=force_refresh_statuses,
-            acquire_per_cluster_status_lock=True,
+            cluster_lock_already_held=False,
             include_user_info=include_user_info,
             summary_response=summary_response)
     except (exceptions.ClusterStatusFetchingError,

sky/backends/cloud_vm_ray_backend.py

@@ -5121,7 +5121,7 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
                         # observed in AWS. See also
                         # _LAUNCH_DOUBLE_CHECK_WINDOW in backend_utils.py.
                         force_refresh_statuses={status_lib.ClusterStatus.INIT},
-                        acquire_per_cluster_status_lock=False))
+                        cluster_lock_already_held=True))
                 cluster_status_fetched = True
             except exceptions.ClusterStatusFetchingError:
                 logger.warning(
@@ -5725,7 +5725,7 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
             record = backend_utils.refresh_cluster_record(
                 cluster_name,
                 force_refresh_statuses={status_lib.ClusterStatus.INIT},
-                acquire_per_cluster_status_lock=False,
+                cluster_lock_already_held=True,
                 include_user_info=False,
                 summary_response=True,
             )

sky/check.py

@@ -621,35 +621,6 @@ def _format_enabled_cloud(cloud_name: str,
     if cloud_name in [repr(sky_clouds.Kubernetes()), repr(sky_clouds.SSH())]:
         return (f'{title}' + _format_context_details(
             cloud_name, show_details=False, ctx2text=ctx2text))
-
-    if cloud_name == repr(sky_clouds.Kubernetes()):
-        # Get enabled contexts for Kubernetes
-        existing_contexts = sky_clouds.Kubernetes.existing_allowed_contexts()
-        if not existing_contexts:
-            return _green_color(cloud_and_capabilities)
-
-        # Check if allowed_contexts is explicitly set in config
-        allowed_contexts = skypilot_config.get_effective_region_config(
-            cloud='kubernetes',
-            region=None,
-            keys=('allowed_contexts',),
-            default_value=None)
-
-        # Format the context info with consistent styling
-        if allowed_contexts is not None:
-            contexts_formatted = []
-            for i, context in enumerate(existing_contexts):
-                symbol = (ux_utils.INDENT_LAST_SYMBOL
-                          if i == len(existing_contexts) -
-                          1 else ux_utils.INDENT_SYMBOL)
-                contexts_formatted.append(f'\n    {symbol}{context}')
-            context_info = f'  Allowed contexts:{"".join(contexts_formatted)}'
-        else:
-            context_info = f'  Active context: {existing_contexts[0]}'
-
-        return (f'{_green_color(cloud_and_capabilities)}\n'
-                f'  {colorama.Style.DIM}{context_info}'
-                f'{colorama.Style.RESET_ALL}')
     return _green_color(cloud_and_capabilities)
 
 

sky/client/cli/command.py

@@ -60,7 +60,6 @@ from sky.adaptors import common as adaptors_common
 from sky.client import sdk
 from sky.client.cli import flags
 from sky.client.cli import table_utils
-from sky.data import storage_utils
 from sky.provision.kubernetes import constants as kubernetes_constants
 from sky.provision.kubernetes import utils as kubernetes_utils
 from sky.schemas.api import responses
@@ -88,9 +87,9 @@ from sky.utils import status_lib
 from sky.utils import subprocess_utils
 from sky.utils import timeline
 from sky.utils import ux_utils
+from sky.utils import volume as volume_utils
 from sky.utils import yaml_utils
 from sky.utils.cli_utils import status_utils
-from sky.volumes import utils as volumes_utils
 from sky.volumes.client import sdk as volumes_sdk
 
 if typing.TYPE_CHECKING:
@@ -1322,7 +1321,7 @@ def exec(
 
 
 def _handle_jobs_queue_request(
-        request_id: server_common.RequestId[List[Dict[str, Any]]],
+        request_id: server_common.RequestId[List[responses.ManagedJobRecord]],
         show_all: bool,
         show_user: bool,
         max_num_jobs_to_show: Optional[int],
@@ -1395,10 +1394,10 @@ def _handle_jobs_queue_request(
         msg += ('Failed to query managed jobs: '
                 f'{common_utils.format_exception(e, use_bracket=True)}')
     else:
-        msg = managed_jobs.format_job_table(managed_jobs_,
-                                            show_all=show_all,
-                                            show_user=show_user,
-                                            max_jobs=max_num_jobs_to_show)
+        msg = table_utils.format_job_table(managed_jobs_,
+                                           show_all=show_all,
+                                           show_user=show_user,
+                                           max_jobs=max_num_jobs_to_show)
     return num_in_progress_jobs, msg
 
 
@@ -1513,9 +1512,9 @@ def _status_kubernetes(show_all: bool):
         click.echo(f'\n{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
                    f'Managed jobs'
                    f'{colorama.Style.RESET_ALL}')
-        msg = managed_jobs.format_job_table(all_jobs,
-                                            show_all=show_all,
-                                            show_user=False)
+        msg = table_utils.format_job_table(all_jobs,
+                                           show_all=show_all,
+                                           show_user=False)
         click.echo(msg)
     if any(['sky-serve-controller' in c.cluster_name for c in all_clusters]):
         # TODO: Parse serve controllers and show services separately.
@@ -2963,9 +2962,9 @@ def _hint_or_raise_for_down_jobs_controller(controller_name: str,
            'jobs (output of `sky jobs queue`) will be lost.')
     click.echo(msg)
     if managed_jobs_:
-        job_table = managed_jobs.format_job_table(managed_jobs_,
-                                                  show_all=False,
-                                                  show_user=True)
+        job_table = table_utils.format_job_table(managed_jobs_,
+                                                 show_all=False,
+                                                 show_user=True)
         msg = controller.value.decline_down_for_dirty_controller_hint
         # Add prefix to each line to align with the bullet point.
         msg += '\n'.join(
@@ -4027,8 +4026,7 @@ def storage_ls(verbose: bool):
     """List storage objects managed by SkyPilot."""
     request_id = sdk.storage_ls()
     storages = sdk.stream_and_get(request_id)
-    storage_table = storage_utils.format_storage_table(storages,
-                                                       show_all=verbose)
+    storage_table = table_utils.format_storage_table(storages, show_all=verbose)
     click.echo(storage_table)
 
 
@@ -4123,13 +4121,15 @@ def volumes():
 @click.option('--infra',
               required=False,
               type=str,
-              help='Infra. Format: k8s, k8s/context-name. '
+              help='Infrastructure to use. '
+              'Format: cloud, cloud/region, cloud/region/zone, or '
+              'k8s/context-name.'
+              'Examples: k8s, k8s/my-context, runpod/US/US-CA-2. '
               'Override the infra defined in the YAML.')
-@click.option(
-    '--type',
-    required=False,
-    type=str,
-    help='Volume type. Format: pvc. Override the type defined in the YAML.')
+@click.option('--type',
+              required=False,
+              type=click.Choice(volume_utils.VolumeType.supported_types()),
+              help='Volume type. Override the type defined in the YAML.')
 @click.option('--size',
               required=False,
               type=str,
@@ -4160,7 +4160,7 @@ def volumes_apply(
         sky volumes apply volume.yaml
         \b
         # Apply a volume from a command.
-        sky volumes apply --name pvc1 --infra k8s --type pvc --size 100Gi
+        sky volumes apply --name pvc1 --infra k8s --type k8s-pvc --size 100Gi
     """
     # pylint: disable=import-outside-toplevel
     from sky.volumes import volume as volume_lib
@@ -4239,8 +4239,8 @@ def volumes_ls(verbose: bool):
     """List volumes managed by SkyPilot."""
     request_id = volumes_sdk.ls()
     all_volumes = sdk.stream_and_get(request_id)
-    volume_table = volumes_utils.format_volume_table(all_volumes,
-                                                     show_all=verbose)
+    volume_table = table_utils.format_volume_table(all_volumes,
+                                                   show_all=verbose)
     click.echo(volume_table)
 
 
@@ -4497,10 +4497,30 @@ def jobs_launch(
     job_id_handle = _async_call_or_wait(request_id, async_call,
                                         'sky.jobs.launch')
 
-    if not async_call and not detach_run:
-        job_ids = job_id_handle[0]
-        if isinstance(job_ids, int) or len(job_ids) == 1:
-            job_id = job_ids if isinstance(job_ids, int) else job_ids[0]
+    if async_call:
+        return
+
+    job_ids = [job_id_handle[0]] if isinstance(job_id_handle[0],
+                                               int) else job_id_handle[0]
+    if pool:
+        # Display the worker assignment for the jobs.
+        logger.debug(f'Getting service records for pool: {pool}')
+        records_request_id = managed_jobs.pool_status(pool_names=pool)
+        service_records = _async_call_or_wait(records_request_id, async_call,
+                                              'sky.jobs.pool_status')
+        logger.debug(f'Pool status: {service_records}')
+        replica_infos = service_records[0]['replica_info']
+        for replica_info in replica_infos:
+            job_id = replica_info.get('used_by', None)
+            if job_id in job_ids:
+                worker_id = replica_info['replica_id']
+                version = replica_info['version']
+                logger.info(f'Job ID: {job_id} assigned to pool {pool} '
+                            f'(worker: {worker_id}, version: {version})')
+
+    if not detach_run:
+        if len(job_ids) == 1:
+            job_id = job_ids[0]
             returncode = managed_jobs.tail_logs(name=None,
                                                 job_id=job_id,
                                                 follow=True,

sky/client/cli/table_utils.py

@@ -1,8 +1,19 @@
 """Utilities for formatting tables for CLI output."""
-from typing import List
+import abc
+from datetime import datetime
+from typing import Dict, List, Optional
 
+import prettytable
+
+from sky import sky_logging
+from sky.jobs import utils as managed_jobs
 from sky.schemas.api import responses
+from sky.skylet import constants
+from sky.utils import common_utils
 from sky.utils import log_utils
+from sky.utils import volume
+
+logger = sky_logging.init_logger(__name__)
 
 
 def format_job_queue(jobs: List[responses.ClusterJobRecord]):
@@ -32,3 +43,270 @@ def format_job_queue(jobs: List[responses.ClusterJobRecord]):
             job.metadata.get('git_commit', '-'),
         ])
     return job_table
+
+
+def format_storage_table(storages: List[responses.StorageRecord],
+                         show_all: bool = False) -> str:
+    """Format the storage table for display.
+
+    Args:
+        storage_table (dict): The storage table.
+
+    Returns:
+        str: The formatted storage table.
+    """
+    storage_table = log_utils.create_table([
+        'NAME',
+        'UPDATED',
+        'STORE',
+        'COMMAND',
+        'STATUS',
+    ])
+
+    for row in storages:
+        launched_at = row.launched_at
+        if show_all:
+            command = row.last_use
+        else:
+            command = common_utils.truncate_long_string(
+                row.last_use, constants.LAST_USE_TRUNC_LENGTH)
+        storage_table.add_row([
+            # NAME
+            row.name,
+            # LAUNCHED
+            log_utils.readable_time_duration(launched_at),
+            # CLOUDS
+            ', '.join([s.value for s in row.store]),
+            # COMMAND,
+            command,
+            # STATUS
+            row.status.value,
+        ])
+    if storages:
+        return str(storage_table)
+    else:
+        return 'No existing storage.'
+
+
+def format_job_table(jobs: List[responses.ManagedJobRecord],
+                     show_all: bool,
+                     show_user: bool,
+                     max_jobs: Optional[int] = None):
+    jobs = [job.model_dump() for job in jobs]
+    return managed_jobs.format_job_table(jobs,
+                                         show_all=show_all,
+                                         show_user=show_user,
+                                         max_jobs=max_jobs)
+
+
+_BASIC_COLUMNS = [
+    'NAME',
+    'TYPE',
+    'INFRA',
+    'SIZE',
+    'USER',
+    'WORKSPACE',
+    'AGE',
+    'STATUS',
+    'LAST_USE',
+    'USED_BY',
+]
+
+
+def _get_infra_str(cloud: Optional[str], region: Optional[str],
+                   zone: Optional[str]) -> str:
+    """Get the infrastructure string for the volume."""
+    infra = ''
+    if cloud:
+        infra += cloud
+    if region:
+        infra += f'/{region}'
+    if zone:
+        infra += f'/{zone}'
+    return infra
+
+
+class VolumeTable(abc.ABC):
+    """The volume table."""
+
+    def __init__(self,
+                 volumes: List[responses.VolumeRecord],
+                 show_all: bool = False):
+        super().__init__()
+        self.table = self._create_table(show_all)
+        self._add_rows(volumes, show_all)
+
+    def _get_row_base_columns(self,
+                              row: responses.VolumeRecord,
+                              show_all: bool = False) -> List[str]:
+        """Get the base columns for a row."""
+        # Convert last_attached_at timestamp to human readable string
+        last_attached_at = row.get('last_attached_at')
+        if last_attached_at is not None:
+            last_attached_at_str = datetime.fromtimestamp(
+                last_attached_at).strftime('%Y-%m-%d %H:%M:%S')
+        else:
+            last_attached_at_str = '-'
+        size = row.get('size', '')
+        if size:
+            size = f'{size}Gi'
+        usedby_str = '-'
+        usedby_clusters = row.get('usedby_clusters')
+        usedby_pods = row.get('usedby_pods')
+        if usedby_clusters:
+            usedby_str = f'{", ".join(usedby_clusters)}'
+        elif usedby_pods:
+            usedby_str = f'{", ".join(usedby_pods)}'
+        if show_all:
+            usedby = usedby_str
+        else:
+            usedby = common_utils.truncate_long_string(
+                usedby_str, constants.USED_BY_TRUNC_LENGTH)
+        infra = _get_infra_str(row.get('cloud'), row.get('region'),
+                               row.get('zone'))
+        return [
+            row.get('name', ''),
+            row.get('type', ''),
+            infra,
+            size,
+            row.get('user_name', '-'),
+            row.get('workspace', '-'),
+            log_utils.human_duration(row.get('launched_at', 0)),
+            row.get('status', ''),
+            last_attached_at_str,
+            usedby,
+        ]
+
+    def _create_table(self, show_all: bool = False) -> prettytable.PrettyTable:
+        """Create the volume table."""
+        raise NotImplementedError
+
+    def _add_rows(self,
+                  volumes: List[responses.VolumeRecord],
+                  show_all: bool = False) -> None:
+        """Add rows to the volume table."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def format(self) -> str:
+        """Format the volume table for display."""
+        raise NotImplementedError
+
+
+class PVCVolumeTable(VolumeTable):
+    """The PVC volume table."""
+
+    def _create_table(self, show_all: bool = False) -> prettytable.PrettyTable:
+        """Create the PVC volume table."""
+        #  If show_all is False, show the table with the columns:
+        #   NAME, TYPE, INFRA, SIZE, USER, WORKSPACE,
+        #   AGE, STATUS, LAST_USE, USED_BY
+        #  If show_all is True, show the table with the columns:
+        #   NAME, TYPE, INFRA, SIZE, USER, WORKSPACE,
+        #   AGE, STATUS, LAST_USE, USED_BY, NAME_ON_CLOUD
+        #   STORAGE_CLASS, ACCESS_MODE
+
+        if show_all:
+            columns = _BASIC_COLUMNS + [
+                'NAME_ON_CLOUD',
+                'STORAGE_CLASS',
+                'ACCESS_MODE',
+            ]
+        else:
+            columns = _BASIC_COLUMNS
+
+        table = log_utils.create_table(columns)
+        return table
+
+    def _add_rows(self,
+                  volumes: List[responses.VolumeRecord],
+                  show_all: bool = False) -> None:
+        """Add rows to the PVC volume table."""
+        for row in volumes:
+            table_row = self._get_row_base_columns(row, show_all)
+            if show_all:
+                table_row.append(row.get('name_on_cloud', ''))
+                table_row.append(
+                    row.get('config', {}).get('storage_class_name', '-'))
+                table_row.append(row.get('config', {}).get('access_mode', ''))
+
+            self.table.add_row(table_row)
+
+    def format(self) -> str:
+        """Format the PVC volume table for display."""
+        return 'Kubernetes PVCs:\n' + str(self.table)
+
+
+class RunPodVolumeTable(VolumeTable):
+    """The RunPod volume table."""
+
+    def _create_table(self, show_all: bool = False) -> prettytable.PrettyTable:
+        """Create the RunPod volume table."""
+        #  If show_all is False, show the table with the columns:
+        #   NAME, TYPE, INFRA, SIZE, USER, WORKSPACE,
+        #   AGE, STATUS, LAST_USE, USED_BY
+        #  If show_all is True, show the table with the columns:
+        #   NAME, TYPE, INFRA, SIZE, USER, WORKSPACE,
+        #   AGE, STATUS, LAST_USE, USED_BY, NAME_ON_CLOUD
+
+        if show_all:
+            columns = _BASIC_COLUMNS + ['NAME_ON_CLOUD']
+        else:
+            columns = _BASIC_COLUMNS
+
+        table = log_utils.create_table(columns)
+        return table
+
+    def _add_rows(self,
+                  volumes: List[responses.VolumeRecord],
+                  show_all: bool = False) -> None:
+        """Add rows to the RunPod volume table."""
+        for row in volumes:
+            table_row = self._get_row_base_columns(row, show_all)
+            if show_all:
+                table_row.append(row.get('name_on_cloud', ''))
+
+            self.table.add_row(table_row)
+
+    def format(self) -> str:
+        """Format the RunPod volume table for display."""
+        return 'RunPod Network Volumes:\n' + str(self.table)
+
+
+def format_volume_table(volumes: List[responses.VolumeRecord],
+                        show_all: bool = False) -> str:
+    """Format the volume table for display.
+
+    Args:
+        volume_table (dict): The volume table.
+
+    Returns:
+        str: The formatted volume table.
+    """
+    volumes_per_type: Dict[str, List[responses.VolumeRecord]] = {}
+    supported_volume_types = [
+        volume_type.value for volume_type in volume.VolumeType
+    ]
+    for row in volumes:
+        volume_type = row.get('type', '')
+        if volume_type in supported_volume_types:
+            if volume_type not in volumes_per_type:
+                volumes_per_type[volume_type] = []
+            volumes_per_type[volume_type].append(row)
+        else:
+            logger.warning(f'Unknown volume type: {volume_type}')
+            continue
+    table_str = ''
+    for volume_type, volume_list in volumes_per_type.items():
+        if table_str:
+            table_str += '\n\n'
+        if volume_type == volume.VolumeType.PVC.value:
+            pvc_table = PVCVolumeTable(volume_list, show_all)
+            table_str += pvc_table.format()
+        elif volume_type == volume.VolumeType.RUNPOD_NETWORK_VOLUME.value:
+            runpod_table = RunPodVolumeTable(volume_list, show_all)
+            table_str += runpod_table.format()
+    if table_str:
+        return table_str
+    else:
+        return 'No existing volumes.'

sky/client/sdk.py

@@ -1618,26 +1618,15 @@ def cost_report(
 @usage_lib.entrypoint
 @server_common.check_server_healthy_or_start
 @annotations.client_api
-def storage_ls() -> server_common.RequestId[List[Dict[str, Any]]]:
+def storage_ls() -> server_common.RequestId[List[responses.StorageRecord]]:
     """Gets the storages.
 
     Returns:
         The request ID of the storage list request.
 
     Request Returns:
-        storage_records (List[Dict[str, Any]]): A list of dicts, with each dict
-            containing the information of a storage.
-
-            .. code-block:: python
-
-                {
-                    'name': (str) storage name,
-                    'launched_at': (int) timestamp of creation,
-                    'store': (List[sky.StoreType]) storage type,
-                    'last_use': (int) timestamp of last use,
-                    'status': (sky.StorageStatus) storage status,
-                }
-        ]
+        storage_records (List[responses.StorageRecord]):
+            A list of storage records.
     """
     response = server_common.make_authenticated_request('GET', '/storage/ls')
     return server_common.get_request_id(response)
@@ -1912,10 +1901,10 @@ def kubernetes_node_info(
 @usage_lib.entrypoint
 @server_common.check_server_healthy_or_start
 @annotations.client_api
-def status_kubernetes() -> server_common.RequestId[Tuple[
-    List['kubernetes_utils.KubernetesSkyPilotClusterInfoPayload'],
-    List['kubernetes_utils.KubernetesSkyPilotClusterInfoPayload'], List[Dict[
-        str, Any]], Optional[str]]]:
+def status_kubernetes() -> server_common.RequestId[
+    Tuple[List['kubernetes_utils.KubernetesSkyPilotClusterInfoPayload'],
+          List['kubernetes_utils.KubernetesSkyPilotClusterInfoPayload'],
+          List[responses.ManagedJobRecord], Optional[str]]]:
     """Gets all SkyPilot clusters and jobs in the Kubernetes cluster.
 
     Managed jobs and services are also included in the clusters returned.