skypilot-nightly 1.0.0.dev20250626__py3-none-any.whl → 1.0.0.dev20250628__py3-none-any.whl

sky/provision/kubernetes/network_utils.py

@@ -28,7 +28,8 @@ _LOADBALANCER_TEMPLATE_NAME = 'kubernetes-loadbalancer.yml.j2'
 
 
 def get_port_mode(
-        mode_str: Optional[str] = None) -> kubernetes_enums.KubernetesPortMode:
+        mode_str: Optional[str],
+        context: Optional[str]) -> kubernetes_enums.KubernetesPortMode:
     """Get the port mode from the provider config."""
 
     curr_kube_config = kubernetes_utils.get_current_kube_config_context_name()
@@ -38,9 +39,11 @@ def get_port_mode(
         # If running in kind (`sky local up`), use ingress mode
         return kubernetes_enums.KubernetesPortMode.INGRESS
 
-    mode_str = mode_str or skypilot_config.get_nested(
-        ('kubernetes', 'ports'),
-        kubernetes_enums.KubernetesPortMode.LOADBALANCER.value)
+    mode_str = mode_str or skypilot_config.get_effective_region_config(
+        cloud='kubernetes',
+        region=context,
+        keys=('ports',),
+        default_value=kubernetes_enums.KubernetesPortMode.LOADBALANCER.value)
     try:
         port_mode = kubernetes_enums.KubernetesPortMode(mode_str)
     except ValueError as e:
@@ -54,12 +57,16 @@ def get_port_mode(
 
 
 def get_networking_mode(
-    mode_str: Optional[str] = None
+    mode_str: Optional[str],
+    context: Optional[str],
 ) -> kubernetes_enums.KubernetesNetworkingMode:
     """Get the networking mode from the provider config."""
-    mode_str = mode_str or skypilot_config.get_nested(
-        ('kubernetes', 'networking_mode'),
-        kubernetes_enums.KubernetesNetworkingMode.PORTFORWARD.value)
+    mode_str = mode_str or skypilot_config.get_effective_region_config(
+        cloud='kubernetes',
+        region=context,
+        keys=('networking_mode',),
+        default_value=kubernetes_enums.KubernetesNetworkingMode.PORTFORWARD.
+        value)
     try:
         networking_mode = kubernetes_enums.KubernetesNetworkingMode.from_str(
             mode_str)
@@ -70,9 +77,9 @@ def get_networking_mode(
     return networking_mode
 
 
-def fill_loadbalancer_template(namespace: str, service_name: str,
-                               ports: List[int], selector_key: str,
-                               selector_value: str) -> Dict:
+def fill_loadbalancer_template(namespace: str, context: Optional[str],
+                               service_name: str, ports: List[int],
+                               selector_key: str, selector_value: str) -> Dict:
     template_path = os.path.join(sky.__root_dir__, 'templates',
                                  _LOADBALANCER_TEMPLATE_NAME)
     if not os.path.exists(template_path):
@@ -81,10 +88,16 @@ def fill_loadbalancer_template(namespace: str, service_name: str,
 
     with open(template_path, 'r', encoding='utf-8') as fin:
         template = fin.read()
-    annotations = skypilot_config.get_nested(
-        ('kubernetes', 'custom_metadata', 'annotations'), {})
-    labels = skypilot_config.get_nested(
-        ('kubernetes', 'custom_metadata', 'labels'), {})
+    annotations = skypilot_config.get_effective_region_config(
+        cloud='kubernetes',
+        region=context,
+        keys=('custom_metadata', 'annotations'),
+        default_value={})
+    labels = skypilot_config.get_effective_region_config(
+        cloud='kubernetes',
+        region=context,
+        keys=('custom_metadata', 'labels'),
+        default_value={})
     j2_template = jinja2.Template(template)
     cont = j2_template.render(
         namespace=namespace,
@@ -99,10 +112,10 @@ def fill_loadbalancer_template(namespace: str, service_name: str,
     return content
 
 
-def fill_ingress_template(namespace: str, service_details: List[Tuple[str, int,
-                                                                      str]],
-                          ingress_name: str, selector_key: str,
-                          selector_value: str) -> Dict:
+def fill_ingress_template(namespace: str, context: Optional[str],
+                          service_details: List[Tuple[str, int,
+                                                      str]], ingress_name: str,
+                          selector_key: str, selector_value: str) -> Dict:
     template_path = os.path.join(sky.__root_dir__, 'templates',
                                  _INGRESS_TEMPLATE_NAME)
     if not os.path.exists(template_path):
@@ -110,10 +123,16 @@ def fill_ingress_template(namespace: str, service_details: List[Tuple[str, int,
             f'Template "{_INGRESS_TEMPLATE_NAME}" does not exist.')
     with open(template_path, 'r', encoding='utf-8') as fin:
         template = fin.read()
-    annotations = skypilot_config.get_nested(
-        ('kubernetes', 'custom_metadata', 'annotations'), {})
-    labels = skypilot_config.get_nested(
-        ('kubernetes', 'custom_metadata', 'labels'), {})
+    annotations = skypilot_config.get_effective_region_config(
+        cloud='kubernetes',
+        region=context,
+        keys=('custom_metadata', 'annotations'),
+        default_value={})
+    labels = skypilot_config.get_effective_region_config(
+        cloud='kubernetes',
+        region=context,
+        keys=('custom_metadata', 'labels'),
+        default_value={})
     j2_template = jinja2.Template(template)
     cont = j2_template.render(
         namespace=namespace,

sky/provision/kubernetes/utils.py

@@ -1190,7 +1190,11 @@ def get_accelerator_label_key_values(
     context_display_name = common_utils.removeprefix(
         context, 'ssh-') if (context and is_ssh_node_pool) else context
 
-    autoscaler_type = get_autoscaler_type()
+    autoscaler_type = skypilot_config.get_effective_region_config(
+        cloud='kubernetes',
+        region=context,
+        keys=('autoscaler',),
+        default_value=None)
     if autoscaler_type is not None:
         # If autoscaler is set in config.yaml, override the label key and value
         # to the autoscaler's format and bypass the GPU checks.
@@ -1595,9 +1599,11 @@ def is_kubeconfig_exec_auth(
     user_details = next(
         user for user in user_details if user['name'] == target_username)
 
-    remote_identity = skypilot_config.get_nested(
-        ('kubernetes', 'remote_identity'),
-        schemas.get_default_remote_identity('kubernetes'))
+    remote_identity = skypilot_config.get_effective_region_config(
+        cloud='kubernetes',
+        region=context,
+        keys=('remote_identity',),
+        default_value=schemas.get_default_remote_identity('kubernetes'))
     if ('exec' in user_details.get('user', {}) and remote_identity
             == schemas.RemoteIdentityOptions.LOCAL_CREDENTIALS.value):
         ctx_name = context_obj['name']
@@ -2078,7 +2084,7 @@ def setup_ssh_jump_svc(ssh_jump_name: str, namespace: str,
     content = fill_ssh_jump_template('', '', ssh_jump_name, service_type.value)
 
     # Add custom metadata from config
-    merge_custom_metadata(content['service_spec']['metadata'])
+    merge_custom_metadata(content['service_spec']['metadata'], context)
 
     # Create service
     try:
@@ -2158,7 +2164,7 @@ def setup_ssh_jump_pod(ssh_jump_name: str, ssh_jump_image: str,
 
     # Add custom metadata to all objects
     for object_type in content.keys():
-        merge_custom_metadata(content[object_type]['metadata'])
+        merge_custom_metadata(content[object_type]['metadata'], context)
 
     # ServiceAccount
     try:
@@ -2370,7 +2376,7 @@ def check_port_forward_mode_dependencies(
     return None
 
 
-def get_endpoint_debug_message() -> str:
+def get_endpoint_debug_message(context: Optional[str] = None) -> str:
     """ Returns a string message for user to debug Kubernetes port opening
 
     Polls the configured ports mode on Kubernetes to produce an
@@ -2378,7 +2384,7 @@ def get_endpoint_debug_message() -> str:
 
     Also checks if the
     """
-    port_mode = network_utils.get_port_mode()
+    port_mode = network_utils.get_port_mode(None, context)
     if port_mode == kubernetes_enums.KubernetesPortMode.INGRESS:
         endpoint_type = 'Ingress'
         debug_cmd = 'kubectl describe ingress && kubectl describe ingressclass'
@@ -2396,6 +2402,7 @@ def combine_pod_config_fields(
     cluster_yaml_path: str,
     cluster_config_overrides: Dict[str, Any],
     cloud: Optional[clouds.Cloud] = None,
+    context: Optional[str] = None,
 ) -> None:
     """Adds or updates fields in the YAML with fields from the
     ~/.sky/config.yaml's kubernetes.pod_spec dict.
@@ -2438,19 +2445,28 @@ def combine_pod_config_fields(
     with open(cluster_yaml_path, 'r', encoding='utf-8') as f:
         yaml_content = f.read()
     yaml_obj = yaml.safe_load(yaml_content)
-    # We don't use override_configs in `skypilot_config.get_nested`, as merging
+    # We don't use override_configs in `get_effective_region_config`, as merging
     # the pod config requires special handling.
     if isinstance(cloud, clouds.SSH):
-        kubernetes_config = skypilot_config.get_nested(('ssh', 'pod_config'),
-                                                       default_value={},
-                                                       override_configs={})
-        override_pod_config = (cluster_config_overrides.get('ssh', {}).get(
-            'pod_config', {}))
+        kubernetes_config = skypilot_config.get_effective_region_config(
+            cloud='ssh', region=None, keys=('pod_config',), default_value={})
+        override_pod_config = config_utils.get_cloud_config_value_from_dict(
+            dict_config=cluster_config_overrides,
+            cloud='ssh',
+            keys=('pod_config',),
+            default_value={})
     else:
-        kubernetes_config = skypilot_config.get_nested(
-            ('kubernetes', 'pod_config'), default_value={}, override_configs={})
-        override_pod_config = (cluster_config_overrides.get(
-            'kubernetes', {}).get('pod_config', {}))
+        kubernetes_config = skypilot_config.get_effective_region_config(
+            cloud='kubernetes',
+            region=context,
+            keys=('pod_config',),
+            default_value={})
+        override_pod_config = config_utils.get_cloud_config_value_from_dict(
+            dict_config=cluster_config_overrides,
+            cloud='kubernetes',
+            region=context,
+            keys=('pod_config',),
+            default_value={})
     config_utils.merge_k8s_configs(kubernetes_config, override_pod_config)
 
     # Merge the kubernetes config into the YAML for both head and worker nodes.
@@ -2462,7 +2478,8 @@ def combine_pod_config_fields(
     common_utils.dump_yaml(cluster_yaml_path, yaml_obj)
 
 
-def combine_metadata_fields(cluster_yaml_path: str) -> None:
+def combine_metadata_fields(cluster_yaml_path: str,
+                            context: Optional[str] = None) -> None:
     """Updates the metadata for all Kubernetes objects created by SkyPilot with
     fields from the ~/.sky/config.yaml's kubernetes.custom_metadata dict.
 
@@ -2472,8 +2489,11 @@ def combine_metadata_fields(cluster_yaml_path: str) -> None:
     with open(cluster_yaml_path, 'r', encoding='utf-8') as f:
         yaml_content = f.read()
     yaml_obj = yaml.safe_load(yaml_content)
-    custom_metadata = skypilot_config.get_nested(
-        ('kubernetes', 'custom_metadata'), {})
+    custom_metadata = skypilot_config.get_effective_region_config(
+        cloud='kubernetes',
+        region=context,
+        keys=('custom_metadata',),
+        default_value={})
 
     # List of objects in the cluster YAML to be updated
     combination_destinations = [
@@ -2496,13 +2516,17 @@ def combine_metadata_fields(cluster_yaml_path: str) -> None:
     common_utils.dump_yaml(cluster_yaml_path, yaml_obj)
 
 
-def merge_custom_metadata(original_metadata: Dict[str, Any]) -> None:
+def merge_custom_metadata(original_metadata: Dict[str, Any],
+                          context: Optional[str] = None) -> None:
     """Merges original metadata with custom_metadata from config
 
     Merge is done in-place, so return is not required
     """
-    custom_metadata = skypilot_config.get_nested(
-        ('kubernetes', 'custom_metadata'), {})
+    custom_metadata = skypilot_config.get_effective_region_config(
+        cloud='kubernetes',
+        region=context,
+        keys=('custom_metadata',),
+        default_value={})
     config_utils.merge_k8s_configs(original_metadata, custom_metadata)
 
 
@@ -2556,7 +2580,7 @@ def create_namespace(namespace: str, context: Optional[str]) -> None:
         return
 
     ns_metadata = dict(name=namespace, labels={'parent': 'skypilot'})
-    merge_custom_metadata(ns_metadata)
+    merge_custom_metadata(ns_metadata, context)
     namespace_obj = kubernetes_client.V1Namespace(metadata=ns_metadata)
     try:
         kubernetes.core_api(context).create_namespace(namespace_obj)
@@ -2582,15 +2606,14 @@ def get_head_pod_name(cluster_name_on_cloud: str):
     return f'{cluster_name_on_cloud}-head'
 
 
-def get_autoscaler_type(
-) -> Optional[kubernetes_enums.KubernetesAutoscalerType]:
-    """Returns the autoscaler type by reading from config"""
-    autoscaler_type = skypilot_config.get_nested(('kubernetes', 'autoscaler'),
-                                                 None)
-    if autoscaler_type is not None:
-        autoscaler_type = kubernetes_enums.KubernetesAutoscalerType(
-            autoscaler_type)
-    return autoscaler_type
+def get_custom_config_k8s_contexts() -> List[str]:
+    """Returns the list of context names from the config"""
+    contexts = skypilot_config.get_effective_region_config(
+        cloud='kubernetes',
+        region=None,
+        keys=('context_configs',),
+        default_value={})
+    return [*contexts] or []
 
 
 # Mapping of known spot label keys and values for different cluster types
@@ -2602,6 +2625,21 @@ SPOT_LABEL_MAP = {
 }
 
 
+def get_autoscaler_type(
+    context: Optional[str] = None
+) -> Optional[kubernetes_enums.KubernetesAutoscalerType]:
+    """Returns the autoscaler type by reading from config"""
+    autoscaler_type = skypilot_config.get_effective_region_config(
+        cloud='kubernetes',
+        region=context,
+        keys=('autoscaler',),
+        default_value=None)
+    if autoscaler_type is not None:
+        autoscaler_type = kubernetes_enums.KubernetesAutoscalerType(
+            autoscaler_type)
+    return autoscaler_type
+
+
 def get_spot_label(
         context: Optional[str] = None) -> Tuple[Optional[str], Optional[str]]:
     """Get the spot label key and value for using spot instances, if supported.
@@ -2625,7 +2663,7 @@ def get_spot_label(
 
     # Check if autoscaler is configured. Allow spot instances if autoscaler type
     # is known to support spot instances.
-    autoscaler_type = get_autoscaler_type()
+    autoscaler_type = get_autoscaler_type(context=context)
     if autoscaler_type == kubernetes_enums.KubernetesAutoscalerType.GKE:
         return SPOT_LABEL_MAP[autoscaler_type.value]
 

sky/provision/nebius/utils.py

@@ -40,8 +40,11 @@ def get_project_by_region(region: str) -> str:
         parent_id=nebius.get_tenant_id())).wait()
 
     #  Check is there project if in config
-    project_id = skypilot_config.get_nested(('nebius', region, 'project_id'),
-                                            None)
+    project_id = skypilot_config.get_effective_region_config(
+        cloud='nebius',
+        region=None,
+        keys=(region, 'project_id'),
+        default_value=None)
     if project_id is not None:
         return project_id
     for project in projects.items:
@@ -184,8 +187,11 @@ def launch(cluster_name_on_cloud: str,
     # https://docs.nebius.com/compute/clusters/gpu
     if platform in nebius_constants.INFINIBAND_INSTANCE_PLATFORMS:
         if preset == '8gpu-128vcpu-1600gb':
-            fabric = skypilot_config.get_nested(('nebius', region, 'fabric'),
-                                                None)
+            fabric = skypilot_config.get_effective_region_config(
+                cloud='nebius',
+                region=None,
+                keys=(region, 'fabric'),
+                default_value=None)
 
             # Auto-select fabric if network_tier=best and no fabric configured
             if (fabric is None and

sky/resources.py

@@ -1064,8 +1064,11 @@ class Resources:
             regions = [r for r in regions if r.name in self._image_id]
 
         # Filter the regions by the skypilot_config
-        ssh_proxy_command_config = skypilot_config.get_nested(
-            (str(self._cloud).lower(), 'ssh_proxy_command'), None)
+        ssh_proxy_command_config = skypilot_config.get_effective_region_config(
+            cloud=str(self._cloud).lower(),
+            region=None,
+            keys=('ssh_proxy_command',),
+            default_value=None)
         if (isinstance(ssh_proxy_command_config, str) or
                 ssh_proxy_command_config is None):
             # All regions are valid as the regions are not specified for the
@@ -1550,8 +1553,11 @@ class Resources:
             # to each cloud if any cloud supports reservations for spot.
             return {}
         specific_reservations = set(
-            skypilot_config.get_nested(
-                (str(self.cloud).lower(), 'specific_reservations'), set()))
+            skypilot_config.get_effective_region_config(
+                cloud=str(self.cloud).lower(),
+                region=self.region,
+                keys=('specific_reservations',),
+                default_value=set()))
 
         if isinstance(self.cloud, clouds.DummyCloud):
             return self.cloud.get_reservations_available_resources(

sky/serve/client/sdk.py

@@ -74,12 +74,11 @@ def up(
             task=dag_str,
             service_name=service_name,
         )
-        response = rest.post(
-            f'{server_common.get_server_url()}/serve/up',
+        response = server_common.make_authenticated_request(
+            'POST',
+            '/serve/up',
             json=json.loads(body.model_dump_json()),
-            timeout=(5, None),
-            cookies=server_common.get_api_cookie_jar(),
-        )
+            timeout=(5, None))
         return server_common.get_request_id(response)
 
 
@@ -136,12 +135,11 @@ def update(
             mode=mode,
         )
 
-        response = rest.post(
-            f'{server_common.get_server_url()}/serve/update',
+        response = server_common.make_authenticated_request(
+            'POST',
+            '/serve/update',
             json=json.loads(body.model_dump_json()),
-            timeout=(5, None),
-            cookies=server_common.get_api_cookie_jar(),
-        )
+            timeout=(5, None))
         return server_common.get_request_id(response)
 
 
@@ -178,12 +176,11 @@ def down(
         all=all,
         purge=purge,
     )
-    response = rest.post(
-        f'{server_common.get_server_url()}/serve/down',
+    response = server_common.make_authenticated_request(
+        'POST',
+        '/serve/down',
         json=json.loads(body.model_dump_json()),
-        timeout=(5, None),
-        cookies=server_common.get_api_cookie_jar(),
-    )
+        timeout=(5, None))
     return server_common.get_request_id(response)
 
 
@@ -213,12 +210,11 @@ def terminate_replica(service_name: str, replica_id: int,
         replica_id=replica_id,
         purge=purge,
     )
-    response = rest.post(
-        f'{server_common.get_server_url()}/serve/terminate-replica',
+    response = server_common.make_authenticated_request(
+        'POST',
+        '/serve/terminate-replica',
         json=json.loads(body.model_dump_json()),
-        timeout=(5, None),
-        cookies=server_common.get_api_cookie_jar(),
-    )
+        timeout=(5, None))
     return server_common.get_request_id(response)
 
 
@@ -286,12 +282,11 @@ def status(
         exceptions.ClusterNotUpError: if the sky serve controller is not up.
     """
     body = payloads.ServeStatusBody(service_names=service_names,)
-    response = rest.post(
-        f'{server_common.get_server_url()}/serve/status',
+    response = server_common.make_authenticated_request(
+        'POST',
+        '/serve/status',
         json=json.loads(body.model_dump_json()),
-        timeout=(5, None),
-        cookies=server_common.get_api_cookie_jar(),
-    )
+        timeout=(5, None))
     return server_common.get_request_id(response)
 
 
@@ -373,13 +368,12 @@ def tail_logs(service_name: str,
         replica_id=replica_id,
         follow=follow,
     )
-    response = rest.post(
-        f'{server_common.get_server_url()}/serve/logs',
+    response = server_common.make_authenticated_request(
+        'POST',
+        '/serve/logs',
         json=json.loads(body.model_dump_json()),
         timeout=(5, None),
-        stream=True,
-        cookies=server_common.get_api_cookie_jar(),
-    )
+        stream=True)
     request_id = server_common.get_request_id(response)
     return sdk.stream_response(request_id=request_id,
                                response=response,
@@ -436,11 +430,11 @@ def sync_down_logs(service_name: str,
         targets=targets,
         replica_ids=replica_ids,
     )
-    response = rest.post(
-        f'{server_common.get_server_url()}/serve/sync-down-logs',
+    response = server_common.make_authenticated_request(
+        'POST',
+        '/serve/sync-down-logs',
         json=json.loads(body.model_dump_json()),
-        timeout=(5, None),
-    )
+        timeout=(5, None))
     remote_dir = sdk.stream_and_get(server_common.get_request_id(response))
 
     # Download from API server paths to the client's local_dir

sky/server/common.py

@@ -27,6 +27,7 @@ from sky import exceptions
 from sky import sky_logging
 from sky import skypilot_config
 from sky.adaptors import common as adaptors_common
+from sky.client import service_account_auth
 from sky.data import data_utils
 from sky.server import constants as server_constants
 from sky.server import rest
@@ -185,6 +186,53 @@ def get_cookies_from_response(
     return cookies
 
 
+def make_authenticated_request(method: str,
+                               path: str,
+                               server_url: Optional[str] = None,
+                               retry: bool = True,
+                               **kwargs) -> 'requests.Response':
+    """Make an authenticated HTTP request to the API server.
+
+    Automatically handles service account token authentication or cookie-based
+    authentication based on what's available.
+
+    Args:
+        method: HTTP method (GET, POST, etc.)
+        path: API path (e.g., '/api/v1/status')
+        server_url: Server URL, defaults to configured server
+        **kwargs: Additional arguments to pass to requests
+
+    Returns:
+        requests.Response object
+    """
+    if server_url is None:
+        server_url = get_server_url()
+
+    # Prepare headers and URL for service account authentication
+    headers = service_account_auth.get_service_account_headers()
+
+    # Merge with existing headers
+    if 'headers' in kwargs:
+        headers.update(kwargs['headers'])
+    kwargs['headers'] = headers
+
+    # Always use the same URL regardless of authentication type
+    # OAuth2 proxy will handle authentication based on headers
+    url = f'{server_url}/{path}' if not path.startswith(
+        '/') else f'{server_url}{path}'
+
+    # Use cookie authentication if no Bearer token present
+    if not headers.get('Authorization') and 'cookies' not in kwargs:
+        kwargs['cookies'] = get_api_cookie_jar()
+
+    # Make the request
+    if retry:
+        return rest.request(method, url, **kwargs)
+    else:
+        assert method == 'GET', 'Only GET requests can be done without retry'
+        return rest.request_without_retry(method, url, **kwargs)
+
+
 @annotations.lru_cache(scope='global')
 def get_server_url(host: Optional[str] = None) -> str:
     endpoint = DEFAULT_SERVER_URL
@@ -243,9 +291,9 @@ def get_api_server_status(endpoint: Optional[str] = None) -> ApiServerInfo:
     server_url = endpoint if endpoint is not None else get_server_url()
     while time_out_try_count <= RETRY_COUNT_ON_TIMEOUT:
         try:
-            response = rest.get(f'{server_url}/api/health',
-                                timeout=2.5,
-                                cookies=get_api_cookie_jar())
+            response = make_authenticated_request('GET',
+                                                  '/api/health',
+                                                  timeout=2.5)
         except requests.exceptions.Timeout:
             if time_out_try_count == RETRY_COUNT_ON_TIMEOUT:
                 return ApiServerInfo(status=ApiServerStatus.UNHEALTHY)

sky/server/constants.py

@@ -36,3 +36,6 @@ API_COOKIE_FILE_DEFAULT_LOCATION = '~/.sky/cookies.txt'
 # The path to the dashboard build output
 DASHBOARD_DIR = os.path.join(os.path.dirname(__file__), '..', 'dashboard',
                              'out')
+
+# The interval (seconds) for the event to be restarted in the background.
+DAEMON_RESTART_INTERVAL_SECONDS = 20

sky/server/requests/executor.py

@@ -268,6 +268,10 @@ def override_request_env_and_config(
     user = models.User(id=request_body.env_vars[constants.USER_ID_ENV_VAR],
                        name=request_body.env_vars[constants.USER_ENV_VAR])
     global_user_state.add_or_update_user(user)
+    # Refetch the user to get the latest user info, including the created_at
+    # field.
+    user = global_user_state.get_user(user.id)
+
     # Force color to be enabled.
     os.environ['CLICOLOR_FORCE'] = '1'
     server_common.reload_for_new_request(

sky/server/requests/payloads.py

@@ -358,6 +358,39 @@ class UserImportBody(RequestBody):
     csv_content: str
 
 
+class ServiceAccountTokenCreateBody(RequestBody):
+    """The request body for creating a service account token."""
+    token_name: str
+    expires_in_days: Optional[int] = None
+
+
+class ServiceAccountTokenDeleteBody(RequestBody):
+    """The request body for deleting a service account token."""
+    token_id: str
+
+
+class UpdateRoleBody(RequestBody):
+    """The request body for updating a user role."""
+    role: str
+
+
+class ServiceAccountTokenRoleBody(RequestBody):
+    """The request body for getting a service account token role."""
+    token_id: str
+
+
+class ServiceAccountTokenUpdateRoleBody(RequestBody):
+    """The request body for updating a service account token role."""
+    token_id: str
+    role: str
+
+
+class ServiceAccountTokenRotateBody(RequestBody):
+    """The request body for rotating a service account token."""
+    token_id: str
+    expires_in_days: Optional[int] = None
+
+
 class DownloadBody(RequestBody):
     """The request body for the download endpoint."""
     folder_paths: List[str]