skypilot-nightly 1.0.0.dev20250417__py3-none-any.whl → 1.0.0.dev20250421__py3-none-any.whl

sky/optimizer.py

@@ -335,9 +335,6 @@ class Optimizer:
                             orig_resources)
 
                 for resources in launchable_list:
-                    if do_print:
-                        logger.debug(f'resources: {resources}')
-
                     if minimize_cost:
                         cost_per_node = resources.get_cost(estimated_runtime)
                         num_available_reserved_nodes = (
@@ -355,13 +352,14 @@ class Optimizer:
                         # Minimize run time.
                         estimated_cost_or_time = estimated_runtime
                     if do_print:
-                        logger.debug(
-                            '  estimated_runtime: {:.0f} s ({:.1f} hr)'.format(
-                                estimated_runtime, estimated_runtime / 3600))
+                        debug_msg = (
+                            f'resources: {resources}, '
+                            f'estimated_runtime: {estimated_runtime} s '
+                            f'({estimated_runtime / 3600:.1f} hr)')
                         if minimize_cost:
-                            logger.debug(
-                                '  estimated_cost (not incl. egress): ${:.1f}'.
-                                format(estimated_cost_or_time))
+                            debug_msg += (', estimated_cost: '
+                                          f'${estimated_cost_or_time:.1f}')
+                        logger.debug(debug_msg)
                     node_to_cost_map[node][resources] = estimated_cost_or_time
             if not node_to_cost_map[node]:
                 source_hint = 'catalog'

sky/provision/provisioner.py

@@ -670,6 +670,7 @@ def post_provision_runtime_setup(
                 ux_utils.error_message(
                     'Failed to set up SkyPilot runtime on cluster.',
                     provision_logging.config.log_path))
-            logger.debug(f'Stacktrace:\n{traceback.format_exc()}')
+            if sky_logging.logging_enabled(logger, sky_logging.DEBUG):
+                logger.debug(f'Stacktrace:\n{traceback.format_exc()}')
             with ux_utils.print_exception_no_traceback():
                 raise

sky/resources.py

@@ -1370,7 +1370,8 @@ class Resources:
         return features
 
     @staticmethod
-    def apply_resource_config_aliases(config: Optional[Dict[str, Any]]) -> None:
+    def _apply_resource_config_aliases(
+            config: Optional[Dict[str, Any]]) -> None:
         """Mutatively applies overriding aliases to the passed in config.
 
         Note: Nested aliases are not supported.
@@ -1399,7 +1400,15 @@ class Resources:
         if config is None:
             return {Resources()}
 
-        Resources.apply_resource_config_aliases(config)
+        Resources._apply_resource_config_aliases(config)
+        anyof = config.get('any_of')
+        if anyof is not None and isinstance(anyof, list):
+            for anyof_config in anyof:
+                Resources._apply_resource_config_aliases(anyof_config)
+        ordered = config.get('ordered')
+        if ordered is not None and isinstance(ordered, list):
+            for ordered_config in ordered:
+                Resources._apply_resource_config_aliases(ordered_config)
         common_utils.validate_schema(config, schemas.get_resources_schema(),
                                      'Invalid resources YAML: ')
 

sky/serve/__init__.py

@@ -3,6 +3,7 @@ import os
 
 from sky.serve.client.sdk import down
 from sky.serve.client.sdk import status
+from sky.serve.client.sdk import sync_down_logs
 from sky.serve.client.sdk import tail_logs
 from sky.serve.client.sdk import terminate_replica
 from sky.serve.client.sdk import up
@@ -37,6 +38,7 @@ __all__ = [
     'LB_POLICIES',
     'ReplicaStatus',
     'ServiceComponent',
+    'sync_down_logs',
     'ServiceStatus',
     'ServeCodeGen',
     'SkyServiceSpec',

sky/serve/autoscalers.py

@@ -676,8 +676,12 @@ class FallbackRequestRateAutoscaler(RequestRateAutoscaler):
             # because the provisioning spot can fail to UP due to the capacity
             # issue, and on-demand should fill the gap between the required
             # number of spot and ready spot.
-            num_ondemand_to_provision += (num_spot_to_provision -
-                                          num_ready_spot)
+            # When scaling down spot instances, it is possible that the number
+            # of ready spot is more than the number of spot to provision, thus
+            # generate a negative number. In this case, we don't need to
+            # provision on-demand instances.
+            num_ondemand_to_provision += max(
+                0, num_spot_to_provision - num_ready_spot)
 
         # Make sure we don't launch on-demand fallback for
         # overprovisioned replicas.

sky/serve/client/sdk.py

@@ -374,3 +374,64 @@ def tail_logs(service_name: str,
     )
     request_id = server_common.get_request_id(response)
     sdk.stream_response(request_id, response, output_stream)
+
+
+@usage_lib.entrypoint
+@server_common.check_server_healthy_or_start
+def sync_down_logs(service_name: str,
+                   local_dir: str,
+                   *,
+                   targets: Optional[Union[
+                       str, 'serve_utils.ServiceComponent',
+                       List[Union[str,
+                                  'serve_utils.ServiceComponent']]]] = None,
+                   replica_ids: Optional[List[int]] = None) -> None:
+    """Sync down logs from the service components to a local directory.
+
+    This function syncs logs from the specified service components (controller,
+    load balancer, replicas) via the API server to a specified local directory.
+
+    Args:
+        service_name: The name of the service to download logs from.
+        targets: Which component(s) to download logs for. If None or empty,
+            means download all logs (controller, load-balancer, all replicas).
+            Can be a string (e.g. "controller"), or a `ServiceComponent` object,
+            or a list of them for multiple components. Currently accepted
+            values:
+                - "controller"/ServiceComponent.CONTROLLER
+                - "load_balancer"/ServiceComponent.LOAD_BALANCER
+                - "replica"/ServiceComponent.REPLICA
+        replica_ids: The list of replica IDs to download logs from, specified
+            when target includes `ServiceComponent.REPLICA`. If target includes
+            `ServiceComponent.REPLICA` but this is None/empty, logs for all
+            replicas will be downloaded.
+        local_dir: Local directory to sync down logs to. Defaults to
+            `~/sky_logs`.
+
+    Raises:
+        RuntimeError: If fails to gather logs or fails to rsync from the
+          controller.
+        sky.exceptions.ClusterNotUpError: If the controller is not up.
+        ValueError: Arguments not valid.
+    """
+    # Avoid circular import.
+    from sky.client import sdk  # pylint: disable=import-outside-toplevel
+
+    body = payloads.ServeDownloadLogsBody(
+        service_name=service_name,
+        # No need to set here, since the server will override it
+        # to a directory on the API server.
+        local_dir=local_dir,
+        targets=targets,
+        replica_ids=replica_ids,
+    )
+    response = requests.post(
+        f'{server_common.get_server_url()}/serve/sync-down-logs',
+        json=json.loads(body.model_dump_json()),
+        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
+    client_common.download_logs_from_api_server([remote_dir], remote_dir,
+                                                local_dir)

sky/serve/replica_managers.py

@@ -257,14 +257,6 @@ class ReplicaStatusProperty:
     # is set to True and it can fail immediately due to spot availability.
     failed_spot_availability: bool = False
 
-    def remove_terminated_replica(self) -> bool:
-        """Whether to remove the replica record from the replica table.
-
-        If not, the replica will stay in the replica table permanently to
-        notify the user that something is wrong with the user code / setup.
-        """
-        return self.is_scale_down
-
     def unrecoverable_failure(self) -> bool:
         """Whether the replica fails and cannot be recovered.
 
@@ -730,6 +722,12 @@ class SkyPilotReplicaManager(ReplicaManager):
                            replica_drain_delay_seconds: int,
                            is_scale_down: bool = False,
                            purge: bool = False) -> None:
+        left_in_record = not (is_scale_down or purge)
+        if left_in_record:
+            assert sync_down_logs, (
+                'For the replica left in the record, '
+                'the logs should always be synced down. '
+                'So that the user can see the logs to debug.')
 
         if replica_id in self._launch_process_pool:
             info = serve_state.get_replica_info_from_id(self._service_name,

sky/serve/serve_utils.py

@@ -13,7 +13,7 @@ import threading
 import time
 import typing
 from typing import (Any, Callable, DefaultDict, Dict, Generic, Iterator, List,
-                    Optional, TextIO, Type, TypeVar)
+                    Optional, TextIO, Type, TypeVar, Union)
 import uuid
 
 import colorama
@@ -81,6 +81,38 @@ class ServiceComponent(enum.Enum):
     REPLICA = 'replica'
 
 
+@dataclasses.dataclass
+class ServiceComponentTarget:
+    """Represents a target service component with an optional replica ID.
+    """
+    component: ServiceComponent
+    replica_id: Optional[int] = None
+
+    def __init__(self,
+                 component: Union[str, ServiceComponent],
+                 replica_id: Optional[int] = None):
+        if isinstance(component, str):
+            component = ServiceComponent(component)
+        self.component = component
+        self.replica_id = replica_id
+
+    def __post_init__(self):
+        """Validate that replica_id is only provided for REPLICA component."""
+        if (self.component
+                == ServiceComponent.REPLICA) != (self.replica_id is None):
+            raise ValueError(
+                'replica_id must be specified if and only if component is '
+                'REPLICA.')
+
+    def __hash__(self) -> int:
+        return hash((self.component, self.replica_id))
+
+    def __str__(self) -> str:
+        if self.component == ServiceComponent.REPLICA:
+            return f'{self.component.value}-{self.replica_id}'
+        return self.component.value
+
+
 class UserSignal(enum.Enum):
     """User signal to send to controller.
 

sky/serve/server/core.py

@@ -1,9 +1,11 @@
 """SkyServe core APIs."""
+import pathlib
 import re
 import signal
 import tempfile
 import threading
-from typing import Any, Dict, List, Optional, Tuple, Union
+import typing
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
 
 import colorama
 
@@ -29,6 +31,9 @@ from sky.utils import rich_utils
 from sky.utils import subprocess_utils
 from sky.utils import ux_utils
 
+if typing.TYPE_CHECKING:
+    from sky.backends import cloud_vm_ray_backend
+
 logger = sky_logging.init_logger(__name__)
 
 
@@ -64,6 +69,41 @@ def _rewrite_tls_credential_paths_and_get_tls_env_vars(
     return tls_template_vars
 
 
+def _get_all_replica_targets(
+    service_name: str, backend: backends.CloudVmRayBackend,
+    handle: backends.CloudVmRayResourceHandle
+) -> Set[serve_utils.ServiceComponentTarget]:
+    """Helper function to get targets for all live replicas."""
+    code = serve_utils.ServeCodeGen.get_service_status([service_name])
+    returncode, serve_status_payload, stderr = backend.run_on_head(
+        handle,
+        code,
+        require_outputs=True,
+        stream_logs=False,
+        separate_stderr=True)
+
+    try:
+        subprocess_utils.handle_returncode(returncode,
+                                           code,
+                                           'Failed to fetch services',
+                                           stderr,
+                                           stream_logs=True)
+    except exceptions.CommandError as e:
+        raise RuntimeError(e.error_msg) from e
+
+    service_records = serve_utils.load_service_status(serve_status_payload)
+    if not service_records:
+        raise ValueError(f'Service {service_name!r} not found.')
+    assert len(service_records) == 1
+    service_record = service_records[0]
+
+    return {
+        serve_utils.ServiceComponentTarget(serve_utils.ServiceComponent.REPLICA,
+                                           replica_info['replica_id'])
+        for replica_info in service_record['replica_info']
+    }
+
+
 @usage_lib.entrypoint
 def up(
     task: 'sky.Task',
@@ -685,11 +725,14 @@ def status(
     return service_records
 
 
+ServiceComponentOrStr = Union[str, serve_utils.ServiceComponent]
+
+
 @usage_lib.entrypoint
 def tail_logs(
     service_name: str,
     *,
-    target: Union[str, serve_utils.ServiceComponent],
+    target: ServiceComponentOrStr,
     replica_id: Optional[int] = None,
     follow: bool = True,
 ) -> None:
@@ -743,10 +786,11 @@ def tail_logs(
             with ux_utils.print_exception_no_traceback():
                 raise ValueError('`replica_id` must be None when using '
                                  'target=CONTROLLER/LOAD_BALANCER.')
+
+    controller_type = controller_utils.Controllers.SKY_SERVE_CONTROLLER
     handle = backend_utils.is_controller_accessible(
-        controller=controller_utils.Controllers.SKY_SERVE_CONTROLLER,
-        stopped_message=(controller_utils.Controllers.SKY_SERVE_CONTROLLER.
-                         value.default_hint_if_non_existent))
+        controller=controller_type,
+        stopped_message=controller_type.value.default_hint_if_non_existent)
 
     backend = backend_utils.get_backend_from_handle(handle)
     assert isinstance(backend, backends.CloudVmRayBackend), backend
@@ -775,3 +819,141 @@ def tail_logs(
                         stream_logs=True,
                         process_stream=False,
                         ssh_mode=command_runner.SshMode.INTERACTIVE)
+
+
+@usage_lib.entrypoint
+def sync_down_logs(
+    service_name: str,
+    *,
+    local_dir: str,
+    targets: Union[ServiceComponentOrStr, List[ServiceComponentOrStr],
+                   None] = None,
+    replica_ids: Optional[List[int]] = None,
+) -> str:
+    """Sync down logs from the controller for the given service.
+
+    This function is called by the server endpoint. It gathers logs from the
+    controller, load balancer, and/or replicas and places them in a directory
+    under the user's log space on the API server filesystem.
+
+    Args:
+        service_name: The name of the service to download logs from.
+        local_dir: The local directory to save the logs to.
+        targets: Which component(s) to download logs for. If None or empty,
+            means download all logs (controller, load-balancer, all replicas).
+            Can be a string (e.g. "controller"), or a `ServiceComponent` object,
+            or a list of them for multiple components. Currently accepted
+            values:
+                - "controller"/ServiceComponent.CONTROLLER
+                - "load_balancer"/ServiceComponent.LOAD_BALANCER
+                - "replica"/ServiceComponent.REPLICA
+        replica_ids: The list of replica IDs to download logs from, specified
+            when target includes `ServiceComponent.REPLICA`. If target includes
+            `ServiceComponent.REPLICA` but this is None/empty, logs for all
+            replicas will be downloaded.
+
+    Returns:
+        A dict mapping component names to local paths where the logs were synced
+        down to.
+
+    Raises:
+        RuntimeError: If fails to gather logs or fails to rsync from the
+          controller.
+        sky.exceptions.ClusterNotUpError: If the controller is not up.
+        ValueError: Arguments not valid.
+    """
+    # Step 0) get the controller handle
+    with rich_utils.safe_status(
+            ux_utils.spinner_message('Checking service status...')):
+        controller_type = controller_utils.Controllers.SKY_SERVE_CONTROLLER
+        handle = backend_utils.is_controller_accessible(
+            controller=controller_type,
+            stopped_message=controller_type.value.default_hint_if_non_existent)
+        backend: backends.CloudVmRayBackend = (
+            backend_utils.get_backend_from_handle(handle))
+
+    requested_components: Set[serve_utils.ServiceComponent] = set()
+    if not targets:
+        # No targets specified -> request all components
+        requested_components = {
+            serve_utils.ServiceComponent.CONTROLLER,
+            serve_utils.ServiceComponent.LOAD_BALANCER,
+            serve_utils.ServiceComponent.REPLICA
+        }
+    else:
+        # Parse provided targets
+        if isinstance(targets, (str, serve_utils.ServiceComponent)):
+            requested_components = {serve_utils.ServiceComponent(targets)}
+        else:  # list
+            requested_components = {
+                serve_utils.ServiceComponent(t) for t in targets
+            }
+
+    normalized_targets: Set[serve_utils.ServiceComponentTarget] = set()
+    if serve_utils.ServiceComponent.CONTROLLER in requested_components:
+        normalized_targets.add(
+            serve_utils.ServiceComponentTarget(
+                serve_utils.ServiceComponent.CONTROLLER))
+    if serve_utils.ServiceComponent.LOAD_BALANCER in requested_components:
+        normalized_targets.add(
+            serve_utils.ServiceComponentTarget(
+                serve_utils.ServiceComponent.LOAD_BALANCER))
+    if serve_utils.ServiceComponent.REPLICA in requested_components:
+        with rich_utils.safe_status(
+                ux_utils.spinner_message('Getting live replica infos...')):
+            replica_targets = _get_all_replica_targets(service_name, backend,
+                                                       handle)
+        if not replica_ids:
+            # Replica target requested but no specific IDs
+            # -> Get all replica logs
+            normalized_targets.update(replica_targets)
+        else:
+            # Replica target requested with specific IDs
+            requested_replica_targets = [
+                serve_utils.ServiceComponentTarget(
+                    serve_utils.ServiceComponent.REPLICA, rid)
+                for rid in replica_ids
+            ]
+            for target in requested_replica_targets:
+                if target not in replica_targets:
+                    logger.warning(f'Replica ID {target.replica_id} not found '
+                                   f'for {service_name}. Skipping...')
+                else:
+                    normalized_targets.add(target)
+
+    def sync_down_logs_by_target(target: serve_utils.ServiceComponentTarget):
+        component = target.component
+        # We need to set one side of the pipe to a logs stream, and the other
+        # side to a file.
+        log_path = str(pathlib.Path(local_dir) / f'{target}.log')
+        stream_logs_code: str
+
+        if component == serve_utils.ServiceComponent.CONTROLLER:
+            stream_logs_code = (
+                serve_utils.ServeCodeGen.stream_serve_process_logs(
+                    service_name, stream_controller=True, follow=False))
+        elif component == serve_utils.ServiceComponent.LOAD_BALANCER:
+            stream_logs_code = (
+                serve_utils.ServeCodeGen.stream_serve_process_logs(
+                    service_name, stream_controller=False, follow=False))
+        elif component == serve_utils.ServiceComponent.REPLICA:
+            replica_id = target.replica_id
+            assert replica_id is not None, service_name
+            stream_logs_code = serve_utils.ServeCodeGen.stream_replica_logs(
+                service_name, replica_id, follow=False)
+        else:
+            assert False, component
+
+        # Refer to the notes in
+        # sky/backends/cloud_vm_ray_backend.py::CloudVmRayBackend::tail_logs.
+        backend.run_on_head(handle,
+                            stream_logs_code,
+                            stream_logs=False,
+                            process_stream=False,
+                            ssh_mode=command_runner.SshMode.INTERACTIVE,
+                            log_path=log_path)
+
+    subprocess_utils.run_in_parallel(sync_down_logs_by_target,
+                                     list(normalized_targets))
+
+    return local_dir

sky/serve/server/server.py

@@ -1,13 +1,17 @@
 """Rest APIs for SkyServe."""
 
+import pathlib
+
 import fastapi
 
 from sky import sky_logging
 from sky.serve.server import core
+from sky.server import common as server_common
 from sky.server import stream_utils
 from sky.server.requests import executor
 from sky.server.requests import payloads
 from sky.server.requests import requests as api_requests
+from sky.skylet import constants
 from sky.utils import common
 
 logger = sky_logging.init_logger(__name__)
@@ -110,3 +114,27 @@ async def tail_logs(
         logs_path=request_task.log_path,
         background_tasks=background_tasks,
     )
+
+
+@router.post('/sync-down-logs')
+async def download_logs(
+    request: fastapi.Request,
+    download_logs_body: payloads.ServeDownloadLogsBody,
+) -> None:
+    user_hash = download_logs_body.env_vars[constants.USER_ID_ENV_VAR]
+    timestamp = sky_logging.get_run_timestamp()
+    logs_dir_on_api_server = (
+        pathlib.Path(server_common.api_server_user_logs_dir_prefix(user_hash)) /
+        'service' / f'{download_logs_body.service_name}_{timestamp}')
+    logs_dir_on_api_server.mkdir(parents=True, exist_ok=True)
+    # We should reuse the original request body, so that the env vars, such as
+    # user hash, are kept the same.
+    download_logs_body.local_dir = str(logs_dir_on_api_server)
+    executor.schedule_request(
+        request_id=request.state.request_id,
+        request_name='serve.sync_down_logs',
+        request_body=download_logs_body,
+        func=core.sync_down_logs,
+        schedule_type=api_requests.ScheduleType.SHORT,
+        request_cluster_name=common.SKY_SERVE_CONTROLLER_NAME,
+    )

sky/server/common.py

@@ -293,7 +293,25 @@ def _start_api_server(deploy: bool = False,
                 time.sleep(0.5)
             else:
                 break
-        logger.info(ux_utils.finishing_message('SkyPilot API server started.'))
+
+        dashboard_msg = (f'Dashboard: {get_server_url(host)}/dashboard')
+        api_server_info = get_api_server_status(get_server_url(host))
+        if api_server_info.version == _DEV_VERSION:
+            dashboard_msg += (
+                f'\n{colorama.Style.RESET_ALL}{ux_utils.INDENT_SYMBOL}'
+                f'{colorama.Fore.YELLOW}')
+            if not os.path.isdir(server_constants.DASHBOARD_DIR):
+                dashboard_msg += (
+                    'Dashboard is not built, '
+                    'to build: npm --prefix sky/dashboard run build')
+            else:
+                dashboard_msg += (
+                    'Dashboard may be stale when installed from source, '
+                    'to rebuild: npm --prefix sky/dashboard run build')
+            dashboard_msg += f'{colorama.Style.RESET_ALL}'
+        logger.info(
+            ux_utils.finishing_message(
+                f'SkyPilot API server started. {dashboard_msg}'))
 
 
 def check_server_healthy(endpoint: Optional[str] = None,) -> None:

sky/server/constants.py

@@ -1,5 +1,7 @@
 """Constants for the API servers."""
 
+import os
+
 from sky.skylet import constants
 
 # API server version, whenever there is a change in API server that requires a
@@ -24,3 +26,7 @@ CLUSTER_REFRESH_DAEMON_INTERVAL_SECONDS = 60
 
 # Environment variable for a file path to the API cookie file.
 API_COOKIE_FILE_ENV_VAR = f'{constants.SKYPILOT_ENV_VAR_PREFIX}API_COOKIE_FILE'
+
+# The path to the dashboard build output
+DASHBOARD_DIR = os.path.join(os.path.dirname(__file__), '..', 'dashboard',
+                             'out')

sky/server/requests/executor.py

@@ -358,6 +358,10 @@ def _request_execution_wrapper(request_id: str,
         # captured in the log file.
         try:
             with override_request_env_and_config(request_body):
+                if sky_logging.logging_enabled(logger, sky_logging.DEBUG):
+                    config = skypilot_config.to_dict()
+                    logger.debug(f'request config: \n'
+                                 f'{common_utils.dump_yaml_str(dict(config))}')
                 return_value = func(**request_body.to_kwargs())
                 f.flush()
         except KeyboardInterrupt:

sky/server/requests/payloads.py

@@ -6,7 +6,6 @@ with the backend functions. The benefit of having the default values in the
 payloads is that a user can find the default values in the Restful API docs.
 """
 import getpass
-import json
 import os
 import typing
 from typing import Any, Dict, List, Optional, Tuple, Union
@@ -47,7 +46,7 @@ def request_body_env_vars() -> dict:
     # Remove the path to config file, as the config content is included in the
     # request body and will be merged with the config on the server side.
     env_vars.pop(skypilot_config.ENV_VAR_SKYPILOT_CONFIG, None)
-    env_vars.pop(skypilot_config.ENV_VAR_USER_CONFIG, None)
+    env_vars.pop(skypilot_config.ENV_VAR_GLOBAL_CONFIG, None)
     env_vars.pop(skypilot_config.ENV_VAR_PROJECT_CONFIG, None)
     return env_vars
 
@@ -56,20 +55,9 @@ def get_override_skypilot_config_from_client() -> Dict[str, Any]:
     """Returns the override configs from the client."""
     config = skypilot_config.to_dict()
     # Remove the API server config, as we should not specify the SkyPilot
-    # server endpoint on the server side. This avoids the warning below.
+    # server endpoint on the server side. This avoids the warning at
+    # server-side.
     config.pop_nested(('api_server',), default_value=None)
-    ignored_key_values = {}
-    for nested_key in constants.SKIPPED_CLIENT_OVERRIDE_KEYS:
-        value = config.pop_nested(nested_key, default_value=None)
-        if value is not None:
-            ignored_key_values['.'.join(nested_key)] = value
-    if ignored_key_values:
-        logger.debug(f'The following keys ({json.dumps(ignored_key_values)}) '
-                     'are specified in the client SkyPilot config at '
-                     f'{skypilot_config.loaded_config_path()!r}. '
-                     'This will be ignored. If you want to specify it, '
-                     'please modify it on server side or contact your '
-                     'administrator.')
     return config
 
 
@@ -420,6 +408,15 @@ class ServeLogsBody(RequestBody):
     follow: bool = True
 
 
+class ServeDownloadLogsBody(RequestBody):
+    """The request body for the serve download logs endpoint."""
+    service_name: str
+    local_dir: str
+    targets: Optional[Union[str, serve.ServiceComponent,
+                            List[Union[str, serve.ServiceComponent]]]]
+    replica_ids: Optional[List[int]] = None
+
+
 class ServeStatusBody(RequestBody):
     """The request body for the serve status endpoint."""
     service_names: Optional[Union[str, List[str]]]