skypilot-nightly 1.0.0.dev20250807__py3-none-any.whl → 1.0.0.dev20250808__py3-none-any.whl

sky/serve/server/impl.py

@@ -198,9 +198,9 @@ def up(
             # We need a unique integer per sky.serve.up call to avoid name
             # conflict. Originally in non-consolidation mode, this is the ray
             # job id; now we use the request id hash instead. Here we also
-            # make sure it is a 63-bit integer to avoid overflow on sqlalchemy.
+            # make sure it is a 32-bit integer to avoid overflow on sqlalchemy.
             rid = common_utils.get_current_request_id()
-            controller_job_id = hash(uuid.UUID(rid).int) & 0x7FFFFFFFFFFFFFFF
+            controller_job_id = hash(uuid.UUID(rid).int) & 0x7FFFFFFF
 
         vars_to_fill = {
             'remote_task_yaml_path': remote_tmp_task_yaml_path,

sky/server/common.py

@@ -16,8 +16,8 @@ import tempfile
 import threading
 import time
 import typing
-from typing import (Any, Callable, cast, Dict, Literal, Optional, Tuple,
-                    TypeVar, Union)
+from typing import (Any, Callable, cast, Dict, Generic, Literal, Optional,
+                    Tuple, TypeVar, Union)
 from urllib import parse
 import uuid
 
@@ -89,16 +89,20 @@ _SERVER_INSTALL_VERSION_MISMATCH_WARNING = (
     'restarting the API server.'
     f'{colorama.Style.RESET_ALL}')
 
-RequestId = str
+T = TypeVar('T')
+P = ParamSpec('P')
+
+
+class RequestId(str, Generic[T]):
+    pass
+
+
 ApiVersion = Optional[str]
 
 logger = sky_logging.init_logger(__name__)
 
 hinted_for_server_install_version_mismatch = False
 
-T = TypeVar('T')
-P = ParamSpec('P')
-
 
 class ApiServerStatus(enum.Enum):
     HEALTHY = 'healthy'
@@ -491,7 +495,7 @@ def handle_request_error(response: 'requests.Response') -> None:
                 f'{response.text}')
 
 
-def get_request_id(response: 'requests.Response') -> RequestId:
+def get_request_id(response: 'requests.Response') -> RequestId[T]:
     handle_request_error(response)
     request_id = response.headers.get('X-Skypilot-Request-ID')
     if request_id is None:
@@ -502,7 +506,7 @@ def get_request_id(response: 'requests.Response') -> RequestId:
                 'Failed to get request ID from SkyPilot API server at '
                 f'{get_server_url()}. Response: {response.status_code} '
                 f'{response.text}')
-    return request_id
+    return RequestId[T](request_id)
 
 
 def _start_api_server(deploy: bool = False,

sky/server/constants.py

@@ -10,7 +10,7 @@ from sky.skylet import constants
 # based on version info is needed.
 # For more details and code guidelines, refer to:
 # https://docs.skypilot.co/en/latest/developers/CONTRIBUTING.html#backward-compatibility-guidelines
-API_VERSION = 15
+API_VERSION = 16
 
 # The minimum peer API version that the code should still work with.
 # Notes (dev):

sky/setup_files/alembic.ini

@@ -94,6 +94,10 @@ version_table = alembic_version_state_db
 version_locations = %(here)s/../schemas/db/spot_jobs
 version_table = alembic_version_spot_jobs_db
 
+[serve_db]
+version_locations = %(here)s/../schemas/db/serve_state
+version_table = alembic_version_serve_state_db
+
 [post_write_hooks]
 # post_write_hooks defines scripts or Python functions that are run
 # on newly generated revision scripts.  See the documentation for further

sky/utils/cli_utils/status_utils.py

@@ -401,7 +401,7 @@ def _get_estimated_cost_for_cost_report(
 
 
 def show_kubernetes_cluster_status_table(
-        clusters: List['kubernetes_utils.KubernetesSkyPilotClusterInfo'],
+        clusters: List['kubernetes_utils.KubernetesSkyPilotClusterInfoPayload'],
         show_all: bool) -> None:
     """Compute cluster table values and display for Kubernetes clusters."""
     status_columns = [

sky/utils/db/db_utils.py

@@ -205,6 +205,37 @@ def add_column_to_table_alembic(
             raise
 
 
+def drop_column_from_table_alembic(
+    table_name: str,
+    column_name: str,
+):
+    """Drop a column from a table using Alembic operations.
+
+    Args:
+        table_name: Name of the table to drop column from.
+        column_name: Name of the column to drop.
+    """
+    from alembic import op  # pylint: disable=import-outside-toplevel
+
+    # Check if column exists before trying to drop it
+    bind = op.get_bind()
+    inspector = sqlalchemy.inspect(bind)
+    columns = [col['name'] for col in inspector.get_columns(table_name)]
+
+    if column_name not in columns:
+        # Column doesn't exist; nothing to do
+        return
+
+    try:
+        op.drop_column(table_name, column_name)
+    except (sqlalchemy_exc.ProgrammingError,
+            sqlalchemy_exc.OperationalError) as e:
+        if 'does not exist' in str(e).lower():
+            pass  # Already dropped
+        else:
+            raise
+
+
 class SQLiteConn(threading.local):
     """Thread-local connection to the sqlite3 database."""
 

sky/utils/db/migration_utils.py

@@ -19,13 +19,17 @@ logger = sky_logging.init_logger(__name__)
 DB_INIT_LOCK_TIMEOUT_SECONDS = 10
 
 GLOBAL_USER_STATE_DB_NAME = 'state_db'
-GLOBAL_USER_STATE_VERSION = '002'
+GLOBAL_USER_STATE_VERSION = '004'
 GLOBAL_USER_STATE_LOCK_PATH = '~/.sky/locks/.state_db.lock'
 
 SPOT_JOBS_DB_NAME = 'spot_jobs_db'
 SPOT_JOBS_VERSION = '003'
 SPOT_JOBS_LOCK_PATH = '~/.sky/locks/.spot_jobs_db.lock'
 
+SERVE_DB_NAME = 'serve_db'
+SERVE_VERSION = '001'
+SERVE_LOCK_PATH = '~/.sky/locks/.serve_db.lock'
+
 
 def get_engine(db_name: str):
     conn_string = None

sky/utils/kubernetes/deploy_remote_cluster.py

@@ -1276,7 +1276,9 @@ def deploy_cluster(head_node,
     print(
         '  • Launch a GPU development pod: sky launch -c devbox --cloud kubernetes'
     )
-    print('  • Connect to pod with VSCode: code --remote ssh-remote+devbox ')
+    print(
+        '  • Connect to pod with VSCode: code --remote ssh-remote+devbox "/home"'
+    )
     # Print completion marker for current cluster
     print(f'{GREEN}SKYPILOT_CLUSTER_COMPLETED: {NC}')
 

sky/utils/resource_checker.py

@@ -74,27 +74,7 @@ def _check_active_resources(resource_operations: List[Tuple[str, str]],
         ValueError: If any resource has active clusters or managed jobs.
     """
 
-    def get_all_clusters():
-        return global_user_state.get_clusters()
-
-    def get_all_managed_jobs():
-        # pylint: disable=import-outside-toplevel
-        from sky.jobs.server import core as managed_jobs_core
-        try:
-            return managed_jobs_core.queue(refresh=False,
-                                           skip_finished=True,
-                                           all_users=True)
-        except exceptions.ClusterNotUpError:
-            logger.warning('All jobs should be finished.')
-            return []
-
-    # Fetch both clusters and jobs in parallel
-    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
-        clusters_future = executor.submit(get_all_clusters)
-        jobs_future = executor.submit(get_all_managed_jobs)
-
-        all_clusters = clusters_future.result()
-        all_managed_jobs = jobs_future.result()
+    all_clusters, all_managed_jobs = _get_active_resources()
 
     # Collect all error messages instead of raising immediately
     error_messages = []
@@ -134,6 +114,11 @@ def _check_active_resources(resource_operations: List[Tuple[str, str]],
         # If this resource has issues, add to overall error messages
         if resource_errors:
             resource_error_summary = ' and '.join(resource_errors)
+            if resource_type == 'user':
+                # resource_name is user_id
+                user_info = global_user_state.get_user(resource_name)
+                if user_info and user_info.name:
+                    resource_name = user_info.name
             error_messages.append(
                 f'Cannot {operation} {resource_type} {resource_name!r} '
                 f'because it has {resource_error_summary}.')
@@ -151,3 +136,159 @@ def _check_active_resources(resource_operations: List[Tuple[str, str]],
                             '\n'.join(f'• {msg}' for msg in error_messages) +
                             '\nPlease terminate these resources first.')
         raise ValueError(full_message)
+
+
+def check_users_workspaces_active_resources(
+        user_ids: List[str],
+        workspace_names: List[str]) -> Tuple[str, List[str]]:
+    """Check if all the active clusters or managed jobs in workspaces
+       belong to the user_ids. If not, return the error message.
+
+    Args:
+        user_ids: List of user_id.
+        workspace_names: List of workspace_name.
+
+    Returns:
+        resource_error_summary: str
+        missed_users_names: List[str]
+    """
+    all_clusters, all_managed_jobs = _get_active_resources_for_workspaces(
+        workspace_names)
+    resource_errors = []
+    missed_users = set()
+    active_cluster_names = []
+    active_job_names = []
+    # Check clusters
+    if all_clusters:
+        for cluster in all_clusters:
+            user_hash = cluster.get('user_hash')
+            if user_hash and user_hash not in user_ids:
+                missed_users.add(user_hash)
+                active_cluster_names.append(cluster['name'])
+        if active_cluster_names:
+            cluster_list = ', '.join(active_cluster_names)
+            resource_errors.append(
+                f'{len(active_cluster_names)} active cluster(s):'
+                f' {cluster_list}')
+
+    # Check managed jobs
+    if all_managed_jobs:
+        for job in all_managed_jobs:
+            user_hash = job.get('user_hash')
+            if user_hash and user_hash not in user_ids:
+                missed_users.add(user_hash)
+                active_job_names.append(str(job['job_id']))
+        if active_job_names:
+            job_list = ', '.join(active_job_names)
+            resource_errors.append(f'{len(active_job_names)} active'
+                                   f' managed job(s): {job_list}')
+
+    resource_error_summary = ''
+    if resource_errors:
+        resource_error_summary = ' and '.join(resource_errors)
+    missed_users_names = []
+    if missed_users:
+        all_users = global_user_state.get_all_users()
+        missed_users_names = [
+            user.name if user.name else user.id
+            for user in all_users
+            if user.id in missed_users
+        ]
+    return resource_error_summary, missed_users_names
+
+
+def _get_active_resources_for_workspaces(
+    workspace_names: List[str]
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+    """Get active clusters or managed jobs for workspaces.
+
+    Args:
+        workspace_names: List of workspace_name.
+
+    Returns:
+        all_clusters: List[Dict[str, Any]]
+        all_managed_jobs: List[Dict[str, Any]]
+    """
+    if not workspace_names:
+        return [], []
+
+    def filter_by_workspaces(workspace_names: List[str]):
+        return lambda resource: (resource.get(
+            'workspace', constants.SKYPILOT_DEFAULT_WORKSPACE) in
+                                 workspace_names)
+
+    return _get_active_resources_by_names(workspace_names, filter_by_workspaces)
+
+
+def _get_active_resources_by_names(
+    resource_names: List[str],
+    filter_factory: Callable[[List[str]], Callable[[Dict[str, Any]], bool]]
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+    """Get active clusters or managed jobs.
+
+    Args:
+        resource_names: List of resource_name.
+        filter_factory: Function that takes a resource_name and returns a filter
+            function for clusters/jobs.
+
+    Returns:
+        all_clusters: List[Dict[str, Any]]
+        all_managed_jobs: List[Dict[str, Any]]
+    """
+
+    all_clusters, all_managed_jobs = _get_active_resources()
+
+    resource_clusters = []
+    resource_active_jobs = []
+
+    # Check each resource against the fetched data,
+    # return the active resources by names
+    resource_filter = filter_factory(resource_names)
+
+    # Filter clusters for this resource
+    if all_clusters:
+        resource_clusters = [
+            cluster for cluster in all_clusters if resource_filter(cluster)
+        ]
+
+    # Filter managed jobs for this resource
+    if all_managed_jobs:
+        resource_active_jobs = [
+            job for job in all_managed_jobs if resource_filter(job)
+        ]
+
+    return resource_clusters, resource_active_jobs
+
+
+def _get_active_resources(
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+    """Get all active clusters and managed jobs.
+
+    Returns:
+        all_clusters: List[Dict[str, Any]]
+        all_managed_jobs: List[Dict[str, Any]]
+    """
+
+    def get_all_clusters():
+        return global_user_state.get_clusters()
+
+    def get_all_managed_jobs():
+        # pylint: disable=import-outside-toplevel
+        from sky.jobs.server import core as managed_jobs_core
+        try:
+            return managed_jobs_core.queue(refresh=False,
+                                           skip_finished=True,
+                                           all_users=True)
+        except exceptions.ClusterNotUpError:
+            logger.warning('All jobs should be finished.')
+            return []
+
+    # Fetch both clusters and jobs in parallel
+    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
+        clusters_future = executor.submit(get_all_clusters)
+        jobs_future = executor.submit(get_all_managed_jobs)
+
+        all_clusters = clusters_future.result()
+        all_managed_jobs = jobs_future.result()
+
+    return all_clusters, all_managed_jobs

sky/volumes/client/sdk.py

@@ -1,7 +1,7 @@
 """SDK functions for managed jobs."""
 import json
 import typing
-from typing import List
+from typing import Any, Dict, List
 
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
@@ -24,7 +24,7 @@ logger = sky_logging.init_logger(__name__)
 @usage_lib.entrypoint
 @server_common.check_server_healthy_or_start
 @annotations.client_api
-def apply(volume: volume_lib.Volume) -> server_common.RequestId:
+def apply(volume: volume_lib.Volume) -> server_common.RequestId[None]:
     """Creates or registers a volume.
 
     Args:
@@ -50,7 +50,7 @@ def apply(volume: volume_lib.Volume) -> server_common.RequestId:
 @usage_lib.entrypoint
 @server_common.check_server_healthy_or_start
 @annotations.client_api
-def ls() -> server_common.RequestId:
+def ls() -> server_common.RequestId[List[Dict[str, Any]]]:
     """Lists all volumes.
 
     Returns:
@@ -65,7 +65,7 @@ def ls() -> server_common.RequestId:
 @usage_lib.entrypoint
 @server_common.check_server_healthy_or_start
 @annotations.client_api
-def delete(names: List[str]) -> server_common.RequestId:
+def delete(names: List[str]) -> server_common.RequestId[None]:
     """Deletes volumes.
 
     Args:

sky/workspaces/core.py

@@ -1,5 +1,6 @@
 """Workspace management core."""
 
+from dataclasses import dataclass
 from typing import Any, Callable, Dict, List, Tuple
 
 import filelock
@@ -9,12 +10,14 @@ from sky import exceptions
 from sky import models
 from sky import sky_logging
 from sky import skypilot_config
+from sky.backends import backend_utils
 from sky.skylet import constants
 from sky.usage import usage_lib
 from sky.users import permission
 from sky.utils import annotations
 from sky.utils import common_utils
 from sky.utils import config_utils
+from sky.utils import locks
 from sky.utils import resource_checker
 from sky.utils import schemas
 from sky.workspaces import utils as workspaces_utils
@@ -24,6 +27,37 @@ logger = sky_logging.init_logger(__name__)
 # Lock for workspace configuration updates to prevent race conditions
 _WORKSPACE_CONFIG_LOCK_TIMEOUT_SECONDS = 60
 
+
+@dataclass
+class WorkspaceConfigComparison:
+    """Result of comparing current and new workspace configurations.
+
+    This class encapsulates the results of analyzing differences between
+    workspace configurations, particularly focusing on user access changes
+    and their implications for resource validation.
+
+    Attributes:
+        only_user_access_changes: True if only allowed_users or private changed
+        private_changed: True if private setting changed
+        private_old: Old private setting value
+        private_new: New private setting value
+        allowed_users_changed: True if allowed_users changed
+        allowed_users_old: Old allowed users list
+        allowed_users_new: New allowed users list
+        removed_users: Users removed from allowed_users
+        added_users: Users added to allowed_users
+    """
+    only_user_access_changes: bool
+    private_changed: bool
+    private_old: bool
+    private_new: bool
+    allowed_users_changed: bool
+    allowed_users_old: List[str]
+    allowed_users_new: List[str]
+    removed_users: List[str]
+    added_users: List[str]
+
+
 # =========================
 # = Workspace Management =
 # =========================
@@ -95,6 +129,153 @@ def _validate_workspace_config(workspace_name: str,
         raise ValueError(str(e)) from e
 
 
+def _compare_workspace_configs(
+    current_config: Dict[str, Any],
+    new_config: Dict[str, Any],
+) -> WorkspaceConfigComparison:
+    """Compare current and new workspace configurations.
+
+    Args:
+        current_config: The current workspace configuration.
+        new_config: The new workspace configuration.
+
+    Returns:
+        WorkspaceConfigComparison object containing the comparison results.
+    """
+    # Get private settings
+    private_old = current_config.get('private', False)
+    private_new = new_config.get('private', False)
+    private_changed = private_old != private_new
+
+    # Get allowed users (resolve to user IDs for comparison)
+    allowed_users_old = workspaces_utils.get_workspace_users(
+        current_config) if private_old else []
+    allowed_users_new = workspaces_utils.get_workspace_users(
+        new_config) if private_new else []
+
+    # Convert to sets for easier comparison
+    old_users_set = set(allowed_users_old)
+    new_users_set = set(allowed_users_new)
+
+    allowed_users_changed = old_users_set != new_users_set
+    removed_users = list(old_users_set - new_users_set)
+    added_users = list(new_users_set - old_users_set)
+
+    # Check if only user access related fields changed
+    # Create copies without the user access fields for comparison
+    current_without_access = {
+        k: v
+        for k, v in current_config.items()
+        if k not in ['private', 'allowed_users']
+    }
+    new_without_access = {
+        k: v
+        for k, v in new_config.items()
+        if k not in ['private', 'allowed_users']
+    }
+
+    only_user_access_changes = current_without_access == new_without_access
+
+    return WorkspaceConfigComparison(
+        only_user_access_changes=only_user_access_changes,
+        private_changed=private_changed,
+        private_old=private_old,
+        private_new=private_new,
+        allowed_users_changed=allowed_users_changed,
+        allowed_users_old=allowed_users_old,
+        allowed_users_new=allowed_users_new,
+        removed_users=removed_users,
+        added_users=added_users)
+
+
+def _validate_workspace_config_changes(workspace_name: str,
+                                       current_config: Dict[str, Any],
+                                       new_config: Dict[str, Any]) -> None:
+    """Validate workspace configuration changes based on active resources.
+
+    This function implements the logic:
+    - If only allowed_users or private changed:
+      - If private changed from true to false: allow it
+      - If private changed from false to true: check that all active resources
+        belong to allowed_users
+      - If private didn't change: check that removed users don't have active
+        resources
+    - Otherwise: check that workspace has no active resources
+
+    Args:
+        workspace_name: The name of the workspace.
+        current_config: The current workspace configuration.
+        new_config: The new workspace configuration.
+
+    Raises:
+        ValueError: If the configuration change is not allowed due to active
+        resources.
+    """
+    config_comparison = _compare_workspace_configs(current_config, new_config)
+
+    if config_comparison.only_user_access_changes:
+        # Only user access settings changed
+        if config_comparison.private_changed:
+            if (config_comparison.private_old and
+                    not config_comparison.private_new):
+                # Changed from private to public - always allow
+                logger.info(
+                    f'Workspace {workspace_name!r} changed from private to'
+                    f' public.')
+                return
+            elif (not config_comparison.private_old and
+                  config_comparison.private_new):
+                # Changed from public to private - check that all active
+                # resources belong to the new allowed users
+                logger.info(
+                    f'Workspace {workspace_name!r} changed from public to'
+                    f' private. Checking that all active resources belong'
+                    f' to allowed users.')
+
+                error_summary, missed_users_names = (
+                    resource_checker.check_users_workspaces_active_resources(
+                        config_comparison.allowed_users_new, [workspace_name]))
+                if error_summary:
+                    error_msg=f'Cannot change workspace {workspace_name!r}' \
+                    f' to private '
+                    if missed_users_names:
+                        missed_users_list = ', '.join(missed_users_names)
+                        if len(missed_users_names) == 1:
+                            error_msg += f'because the user ' \
+                            f'{missed_users_list!r} has {error_summary}'
+                        else:
+                            error_msg += f'because the users ' \
+                            f'{missed_users_list!r} have {error_summary}'
+                        error_msg += ' but not in the allowed_users list.' \
+                        ' Please either add the users to allowed_users or' \
+                        ' ask them to terminate their resources.'
+                    raise ValueError(error_msg)
+        else:
+            # Private setting didn't change, but allowed_users changed
+            if (config_comparison.allowed_users_changed and
+                    config_comparison.removed_users):
+                # Check that removed users don't have active resources
+                logger.info(
+                    f'Checking that removed users'
+                    f' {config_comparison.removed_users} do not have'
+                    f' active resources in workspace {workspace_name!r}.')
+                user_operations = []
+                for user_id in config_comparison.removed_users:
+                    user_operations.append((user_id, 'remove'))
+                resource_checker.check_no_active_resources_for_users(
+                    user_operations)
+    else:
+        # Other configuration changes - check that workspace has no active
+        # resources
+        logger.info(
+            f'Non-user-access configuration changes detected for'
+            f' workspace {workspace_name!r}. Checking that workspace has'
+            f' no active resources.')
+        resource_checker.check_no_active_resources_for_workspaces([
+            (workspace_name, 'update')
+        ])
+
+
 @usage_lib.entrypoint
 def update_workspace(workspace_name: str, config: Dict[str,
                                                        Any]) -> Dict[str, Any]:
@@ -109,17 +290,40 @@ def update_workspace(workspace_name: str, config: Dict[str,
 
     Raises:
         ValueError: If the workspace configuration is invalid, or if there are
-            active clusters or managed jobs in the workspace.
+            active clusters or managed jobs that prevent the configuration
+            change.
+            The validation logic depends on what changed:
+            - If only allowed_users or private changed:
+              - Private true->false: Always allowed
+              - Private false->true: All active resources must belong to
+                allowed_users
+              - allowed_users changes: Removed users must not have active
+                resources
+            - Other changes: Workspace must have no active resources
         FileNotFoundError: If the config file cannot be found.
         PermissionError: If the config file cannot be written.
     """
     _validate_workspace_config(workspace_name, config)
 
-    # Check for active clusters and managed jobs in the workspace
-    # TODO(zhwu): we should allow the edits that only contain changes to
-    # allowed_users or private.
-    resource_checker.check_no_active_resources_for_workspaces([(workspace_name,
-                                                                'update')])
+    # Get the current workspace configuration for comparison
+    current_workspaces = skypilot_config.get_nested(('workspaces',),
+                                                    default_value={})
+    current_config = current_workspaces.get(workspace_name, {})
+
+    if current_config:
+        lock_id = backend_utils.workspace_lock_id(workspace_name)
+        lock_timeout = backend_utils.WORKSPACE_LOCK_TIMEOUT_SECONDS
+        try:
+            with locks.get_lock(lock_id, lock_timeout):
+                # Validate the configuration changes based on active resources
+                _validate_workspace_config_changes(workspace_name,
+                                                   current_config, config)
+        except locks.LockTimeout as e:
+            raise RuntimeError(
+                f'Failed to validate workspace {workspace_name!r} due to '
+                'a timeout when trying to access database. Please '
+                f'try again or manually remove the lock at {lock_id}. '
+                f'{common_utils.format_exception(e)}') from None
 
     def update_workspace_fn(workspaces: Dict[str, Any]) -> None:
         """Function to update workspace inside the lock."""

{skypilot_nightly-1.0.0.dev20250807.dist-info → skypilot_nightly-1.0.0.dev20250808.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skypilot-nightly
-Version: 1.0.0.dev20250807
+Version: 1.0.0.dev20250808
 Summary: SkyPilot: Run AI on Any Infra — Unified, Faster, Cheaper.
 Author: SkyPilot Team
 License: Apache 2.0
@@ -238,7 +238,7 @@ Dynamic: summary
 ----
 
 :fire: *News* :fire:
-- [Aug 2025] Run and serve **OpenAI GPT-OSS models** (gpt-oss-120b, gpt-oss-20b) with one command on any infra: [**example**](./llm/gpt-oss/)
+- [Aug 2025] Serve and finetune **OpenAI GPT-OSS models** (gpt-oss-120b, gpt-oss-20b) with one command on any infra: [**serve**](./llm/gpt-oss/) + [**LoRA and full finetuning**](./llm/gpt-oss-finetuning/)
 - [Jul 2025] Run distributed **RL training for LLMs** with Verl (PPO, GRPO) on any cloud: [**example**](./llm/verl/)
 - [Jul 2025] 🎉 SkyPilot v0.10.0 released! [**blog post**](https://blog.skypilot.co/announcing-skypilot-0.10.0/), [**release notes**](https://github.com/skypilot-org/skypilot/releases/tag/v0.10.0)
 - [Jul 2025] Finetune **Llama4** on any distributed cluster/cloud: [**example**](./llm/llama-4-finetuning/)