skypilot-nightly 1.0.0.dev20250523__py3-none-any.whl → 1.0.0.dev20250526__py3-none-any.whl

sky/jobs/constants.py

@@ -47,7 +47,7 @@ JOBS_CLUSTER_NAME_PREFIX_LENGTH = 25
 # The version of the lib files that jobs/utils use. Whenever there is an API
 # change for the jobs/utils, we need to bump this version and update
 # job.utils.ManagedJobCodeGen to handle the version update.
-MANAGED_JOBS_VERSION = 3
+MANAGED_JOBS_VERSION = 4
 
 # The command for setting up the jobs dashboard on the controller. It firstly
 # checks if the systemd services are available, and if not (e.g., Kubernetes

sky/jobs/server/core.py

@@ -17,6 +17,7 @@ from sky import execution
 from sky import global_user_state
 from sky import provision as provision_lib
 from sky import sky_logging
+from sky import skypilot_config
 from sky import task as task_lib
 from sky.backends import backend_utils
 from sky.clouds.service_catalog import common as service_catalog_common
@@ -207,7 +208,7 @@ def launch(
 
         controller_task.managed_job_dag = dag
 
-        sky_logging.print(
+        logger.info(
             f'{colorama.Fore.YELLOW}'
             f'Launching managed job {dag.name!r} from jobs controller...'
             f'{colorama.Style.RESET_ALL}')
@@ -215,12 +216,20 @@ def launch(
         # Launch with the api server's user hash, so that sky status does not
         # show the owner of the controller as whatever user launched it first.
         with common.with_server_user_hash():
-            return execution.launch(task=controller_task,
-                                    cluster_name=controller_name,
-                                    stream_logs=stream_logs,
-                                    retry_until_up=True,
-                                    fast=True,
-                                    _disable_controller_check=True)
+            # Always launch the controller in the default workspace.
+            with skypilot_config.local_active_workspace_ctx(
+                    skylet_constants.SKYPILOT_DEFAULT_WORKSPACE):
+                # TODO(zhwu): the buckets need to be correctly handled for
+                # a specific workspace. For example, if a job is launched in
+                # workspace A, but the controller is in workspace B, the
+                # intermediate bucket and newly created bucket should be in
+                # workspace A.
+                return execution.launch(task=controller_task,
+                                        cluster_name=controller_name,
+                                        stream_logs=stream_logs,
+                                        retry_until_up=True,
+                                        fast=True,
+                                        _disable_controller_check=True)
 
 
 def queue_from_kubernetes_pod(
@@ -318,14 +327,17 @@ def _maybe_restart_controller(
     if handle is not None:
         return handle
 
-    sky_logging.print(f'{colorama.Fore.YELLOW}'
-                      f'Restarting {jobs_controller_type.value.name}...'
-                      f'{colorama.Style.RESET_ALL}')
+    logger.info(f'{colorama.Fore.YELLOW}'
+                f'Restarting {jobs_controller_type.value.name}...'
+                f'{colorama.Style.RESET_ALL}')
 
     rich_utils.force_update_status(
         ux_utils.spinner_message(f'{spinner_message} - restarting '
                                  'controller'))
-    handle = core.start(cluster_name=jobs_controller_type.value.cluster_name)
+    with skypilot_config.local_active_workspace_ctx(
+            skylet_constants.SKYPILOT_DEFAULT_WORKSPACE):
+        handle = core.start(
+            cluster_name=jobs_controller_type.value.cluster_name)
     # Make sure the dashboard is running when the controller is restarted.
     # We should not directly use execution.launch() and have the dashboard cmd
     # in the task setup because since we are using detached_setup, it will
@@ -440,52 +452,56 @@ def cancel(name: Optional[str] = None,
         sky.exceptions.ClusterNotUpError: the jobs controller is not up.
         RuntimeError: failed to cancel the job.
     """
-    job_ids = [] if job_ids is None else job_ids
-    handle = backend_utils.is_controller_accessible(
-        controller=controller_utils.Controllers.JOBS_CONTROLLER,
-        stopped_message='All managed jobs should have finished.')
-
-    job_id_str = ','.join(map(str, job_ids))
-    if sum([bool(job_ids), name is not None, all or all_users]) != 1:
-        arguments = []
-        arguments += [f'job_ids={job_id_str}'] if job_ids else []
-        arguments += [f'name={name}'] if name is not None else []
-        arguments += ['all'] if all else []
-        arguments += ['all_users'] if all_users else []
-        with ux_utils.print_exception_no_traceback():
-            raise ValueError('Can only specify one of JOB_IDS, name, or all/'
-                             f'all_users. Provided {" ".join(arguments)!r}.')
-
-    backend = backend_utils.get_backend_from_handle(handle)
-    assert isinstance(backend, backends.CloudVmRayBackend)
-    if all_users:
-        code = managed_job_utils.ManagedJobCodeGen.cancel_jobs_by_id(
-            None, all_users=True)
-    elif all:
-        code = managed_job_utils.ManagedJobCodeGen.cancel_jobs_by_id(None)
-    elif job_ids:
-        code = managed_job_utils.ManagedJobCodeGen.cancel_jobs_by_id(job_ids)
-    else:
-        assert name is not None, (job_ids, name, all)
-        code = managed_job_utils.ManagedJobCodeGen.cancel_job_by_name(name)
-    # The stderr is redirected to stdout
-    returncode, stdout, _ = backend.run_on_head(handle,
-                                                code,
-                                                require_outputs=True,
-                                                stream_logs=False)
-    try:
-        subprocess_utils.handle_returncode(returncode, code,
-                                           'Failed to cancel managed job',
-                                           stdout)
-    except exceptions.CommandError as e:
-        with ux_utils.print_exception_no_traceback():
-            raise RuntimeError(e.error_msg) from e
+    with rich_utils.safe_status(
+            ux_utils.spinner_message('Cancelling managed jobs')):
+        job_ids = [] if job_ids is None else job_ids
+        handle = backend_utils.is_controller_accessible(
+            controller=controller_utils.Controllers.JOBS_CONTROLLER,
+            stopped_message='All managed jobs should have finished.')
+
+        job_id_str = ','.join(map(str, job_ids))
+        if sum([bool(job_ids), name is not None, all or all_users]) != 1:
+            arguments = []
+            arguments += [f'job_ids={job_id_str}'] if job_ids else []
+            arguments += [f'name={name}'] if name is not None else []
+            arguments += ['all'] if all else []
+            arguments += ['all_users'] if all_users else []
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(
+                    'Can only specify one of JOB_IDS, name, or all/'
+                    f'all_users. Provided {" ".join(arguments)!r}.')
+
+        backend = backend_utils.get_backend_from_handle(handle)
+        assert isinstance(backend, backends.CloudVmRayBackend)
+        if all_users:
+            code = managed_job_utils.ManagedJobCodeGen.cancel_jobs_by_id(
+                None, all_users=True)
+        elif all:
+            code = managed_job_utils.ManagedJobCodeGen.cancel_jobs_by_id(None)
+        elif job_ids:
+            code = managed_job_utils.ManagedJobCodeGen.cancel_jobs_by_id(
+                job_ids)
+        else:
+            assert name is not None, (job_ids, name, all)
+            code = managed_job_utils.ManagedJobCodeGen.cancel_job_by_name(name)
+        # The stderr is redirected to stdout
+        returncode, stdout, stderr = backend.run_on_head(handle,
+                                                         code,
+                                                         require_outputs=True,
+                                                         stream_logs=False)
+        try:
+            subprocess_utils.handle_returncode(returncode, code,
+                                               'Failed to cancel managed job',
+                                               stdout + stderr)
+        except exceptions.CommandError as e:
+            with ux_utils.print_exception_no_traceback():
+                raise RuntimeError(e.error_msg) from e
 
-    sky_logging.print(stdout)
-    if 'Multiple jobs found with name' in stdout:
-        with ux_utils.print_exception_no_traceback():
-            raise RuntimeError(
-                'Please specify the job ID instead of the job name.')
+        logger.info(stdout)
+        if 'Multiple jobs found with name' in stdout:
+            with ux_utils.print_exception_no_traceback():
+                raise RuntimeError(
+                    'Please specify the job ID instead of the job name.')
 
 
 @usage_lib.entrypoint

sky/jobs/state.py

@@ -13,6 +13,7 @@ import colorama
 
 from sky import exceptions
 from sky import sky_logging
+from sky.skylet import constants
 from sky.utils import common_utils
 from sky.utils import db_utils
 
@@ -118,7 +119,8 @@ def create_table(cursor, conn):
         controller_pid INTEGER DEFAULT NULL,
         dag_yaml_path TEXT,
         env_file_path TEXT,
-        user_hash TEXT)""")
+        user_hash TEXT,
+        workspace TEXT DEFAULT NULL)""")
 
     db_utils.add_column_to_table(cursor, conn, 'job_info', 'schedule_state',
                                  'TEXT')
@@ -134,6 +136,12 @@ def create_table(cursor, conn):
 
     db_utils.add_column_to_table(cursor, conn, 'job_info', 'user_hash', 'TEXT')
 
+    db_utils.add_column_to_table(cursor,
+                                 conn,
+                                 'job_info',
+                                 'workspace',
+                                 'TEXT DEFAULT NULL',
+                                 value_to_replace_existing_entries='default')
     conn.commit()
 
 
@@ -190,6 +198,7 @@ columns = [
     'dag_yaml_path',
     'env_file_path',
     'user_hash',
+    'workspace',
 ]
 
 
@@ -380,14 +389,14 @@ class ManagedJobScheduleState(enum.Enum):
 
 
 # === Status transition functions ===
-def set_job_info(job_id: int, name: str):
+def set_job_info(job_id: int, name: str, workspace: str):
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute(
             """\
             INSERT INTO job_info
-            (spot_job_id, name, schedule_state)
-            VALUES (?, ?, ?)""",
-            (job_id, name, ManagedJobScheduleState.INACTIVE.value))
+            (spot_job_id, name, schedule_state, workspace)
+            VALUES (?, ?, ?, ?)""",
+            (job_id, name, ManagedJobScheduleState.INACTIVE.value, workspace))
 
 
 def set_pending(job_id: int, task_id: int, task_name: str, resources_str: str):
@@ -1116,3 +1125,15 @@ def get_waiting_job() -> Optional[Dict[str, Any]]:
             'dag_yaml_path': row[2],
             'env_file_path': row[3],
         } if row is not None else None
+
+
+def get_workspace(job_id: int) -> str:
+    """Get the workspace of a job."""
+    with db_utils.safe_cursor(_DB_PATH) as cursor:
+        workspace = cursor.execute(
+            'SELECT workspace FROM job_info WHERE spot_job_id = (?)',
+            (job_id,)).fetchone()
+        job_workspace = workspace[0] if workspace else None
+        if job_workspace is None:
+            return constants.SKYPILOT_DEFAULT_WORKSPACE
+        return job_workspace

sky/jobs/utils.py

@@ -23,6 +23,7 @@ from sky import backends
 from sky import exceptions
 from sky import global_user_state
 from sky import sky_logging
+from sky import skypilot_config
 from sky.adaptors import common as adaptors_common
 from sky.backends import backend_utils
 from sky.jobs import constants as managed_job_constants
@@ -463,7 +464,8 @@ def generate_managed_job_cluster_name(task_name: str, job_id: int) -> str:
 
 
 def cancel_jobs_by_id(job_ids: Optional[List[int]],
-                      all_users: bool = False) -> str:
+                      all_users: bool = False,
+                      current_workspace: Optional[str] = None) -> str:
     """Cancel jobs by id.
 
     If job_ids is None, cancel all jobs.
@@ -474,9 +476,11 @@ def cancel_jobs_by_id(job_ids: Optional[List[int]],
     job_ids = list(set(job_ids))
     if not job_ids:
         return 'No job to cancel.'
-    job_id_str = ', '.join(map(str, job_ids))
-    logger.info(f'Cancelling jobs {job_id_str}.')
+    if current_workspace is None:
+        current_workspace = constants.SKYPILOT_DEFAULT_WORKSPACE
+
     cancelled_job_ids: List[int] = []
+    wrong_workspace_job_ids: List[int] = []
     for job_id in job_ids:
         # Check the status of the managed job status. If it is in
         # terminal state, we can safely skip it.
@@ -491,6 +495,11 @@ def cancel_jobs_by_id(job_ids: Optional[List[int]],
 
         update_managed_jobs_statuses(job_id)
 
+        job_workspace = managed_job_state.get_workspace(job_id)
+        if current_workspace is not None and job_workspace != current_workspace:
+            wrong_workspace_job_ids.append(job_id)
+            continue
+
         # Send the signal to the jobs controller.
         signal_file = pathlib.Path(SIGNAL_FILE_PREFIX.format(job_id))
         # Filelock is needed to prevent race condition between signal
@@ -501,17 +510,30 @@ def cancel_jobs_by_id(job_ids: Optional[List[int]],
                 f.flush()
         cancelled_job_ids.append(job_id)
 
+    wrong_workspace_job_str = ''
+    if wrong_workspace_job_ids:
+        plural = 's' if len(wrong_workspace_job_ids) > 1 else ''
+        plural_verb = 'are' if len(wrong_workspace_job_ids) > 1 else 'is'
+        wrong_workspace_job_str = (
+            f' Job{plural} with ID{plural}'
+            f' {", ".join(map(str, wrong_workspace_job_ids))} '
+            f'{plural_verb} skipped as they are not in the active workspace '
+            f'{current_workspace!r}. Check the workspace of the job with: '
+            f'sky jobs queue')
+
     if not cancelled_job_ids:
-        return 'No job to cancel.'
+        return f'No job to cancel.{wrong_workspace_job_str}'
     identity_str = f'Job with ID {cancelled_job_ids[0]} is'
     if len(cancelled_job_ids) > 1:
         cancelled_job_ids_str = ', '.join(map(str, cancelled_job_ids))
         identity_str = f'Jobs with IDs {cancelled_job_ids_str} are'
 
-    return f'{identity_str} scheduled to be cancelled.'
+    msg = f'{identity_str} scheduled to be cancelled.{wrong_workspace_job_str}'
+    return msg
 
 
-def cancel_job_by_name(job_name: str) -> str:
+def cancel_job_by_name(job_name: str,
+                       current_workspace: Optional[str] = None) -> str:
     """Cancel a job by name."""
     job_ids = managed_job_state.get_nonterminal_job_ids_by_name(job_name)
     if not job_ids:
@@ -520,8 +542,8 @@ def cancel_job_by_name(job_name: str) -> str:
         return (f'{colorama.Fore.RED}Multiple running jobs found '
                 f'with name {job_name!r}.\n'
                 f'Job IDs: {job_ids}{colorama.Style.RESET_ALL}')
-    cancel_jobs_by_id(job_ids)
-    return f'Job {job_name!r} is scheduled to be cancelled.'
+    msg = cancel_jobs_by_id(job_ids, current_workspace=current_workspace)
+    return f'{job_name!r} {msg}'
 
 
 def stream_logs_by_id(job_id: int, follow: bool = True) -> Tuple[str, int]:
@@ -1020,10 +1042,15 @@ def format_job_table(
         jobs[get_hash(task)].append(task)
 
     status_counts: Dict[str, int] = collections.defaultdict(int)
+    workspaces = set()
     for job_tasks in jobs.values():
         managed_job_status = _get_job_status_from_tasks(job_tasks)[0]
         if not managed_job_status.is_terminal():
             status_counts[managed_job_status.value] += 1
+        workspaces.add(job_tasks[0].get('workspace',
+                                        constants.SKYPILOT_DEFAULT_WORKSPACE))
+
+    show_workspace = len(workspaces) > 1 or show_all
 
     user_cols: List[str] = []
     if show_user:
@@ -1034,6 +1061,7 @@ def format_job_table(
     columns = [
         'ID',
         'TASK',
+        *(['WORKSPACE'] if show_workspace else []),
         'NAME',
         *user_cols,
         'REQUESTED',
@@ -1093,6 +1121,8 @@ def format_job_table(
     for job_hash, job_tasks in jobs.items():
         if show_all:
             schedule_state = job_tasks[0]['schedule_state']
+        workspace = job_tasks[0].get('workspace',
+                                     constants.SKYPILOT_DEFAULT_WORKSPACE)
 
         if len(job_tasks) > 1:
             # Aggregate the tasks into a new row in the table.
@@ -1134,6 +1164,7 @@ def format_job_table(
             job_values = [
                 job_id,
                 '',
+                *([''] if show_workspace else []),
                 job_name,
                 *user_values,
                 '-',
@@ -1163,9 +1194,11 @@ def format_job_table(
                 0, task['job_duration'], absolute=True)
             submitted = log_utils.readable_time_duration(task['submitted_at'])
             user_values = get_user_column_values(task)
+            task_workspace = '-' if len(job_tasks) > 1 else workspace
             values = [
                 task['job_id'] if len(job_tasks) == 1 else ' \u21B3',
                 task['task_id'] if len(job_tasks) > 1 else '-',
+                *([task_workspace] if show_workspace else []),
                 task['task_name'],
                 *user_values,
                 task['resources'],
@@ -1263,22 +1296,36 @@ class ManagedJobCodeGen:
     def cancel_jobs_by_id(cls,
                           job_ids: Optional[List[int]],
                           all_users: bool = False) -> str:
+        active_workspace = skypilot_config.get_active_workspace()
         code = textwrap.dedent(f"""\
         if managed_job_version < 2:
             # For backward compatibility, since all_users is not supported
-            # before #4787. Assume th
+            # before #4787.
             # TODO(cooperc): Remove compatibility before 0.12.0
             msg = utils.cancel_jobs_by_id({job_ids})
-        else:
+        elif managed_job_version < 4:
+            # For backward compatibility, since current_workspace is not
+            # supported before #5660. Don't check the workspace.
+            # TODO(zhwu): Remove compatibility before 0.12.0
             msg = utils.cancel_jobs_by_id({job_ids}, all_users={all_users})
+        else:
+            msg = utils.cancel_jobs_by_id({job_ids}, all_users={all_users},
+                            current_workspace={active_workspace!r})
         print(msg, end="", flush=True)
         """)
         return cls._build(code)
 
     @classmethod
     def cancel_job_by_name(cls, job_name: str) -> str:
+        active_workspace = skypilot_config.get_active_workspace()
         code = textwrap.dedent(f"""\
-        msg = utils.cancel_job_by_name({job_name!r})
+        if managed_job_version < 4:
+            # For backward compatibility, since current_workspace is not
+            # supported before #5660. Don't check the workspace.
+            # TODO(zhwu): Remove compatibility before 0.12.0
+            msg = utils.cancel_job_by_name({job_name!r})
+        else:
+            msg = utils.cancel_job_by_name({job_name!r}, {active_workspace!r})
         print(msg, end="", flush=True)
         """)
         return cls._build(code)
@@ -1314,11 +1361,16 @@ class ManagedJobCodeGen:
         return cls._build(code)
 
     @classmethod
-    def set_pending(cls, job_id: int, managed_job_dag: 'dag_lib.Dag') -> str:
+    def set_pending(cls, job_id: int, managed_job_dag: 'dag_lib.Dag',
+                    workspace) -> str:
         dag_name = managed_job_dag.name
         # Add the managed job to queue table.
         code = textwrap.dedent(f"""\
-            managed_job_state.set_job_info({job_id}, {dag_name!r})
+            set_job_info_kwargs = {{'workspace': {workspace!r}}}
+            if managed_job_version < 4:
+                set_job_info_kwargs = {{}}
+            managed_job_state.set_job_info(
+                {job_id}, {dag_name!r}, **set_job_info_kwargs)
             """)
         for task_id, task in enumerate(managed_job_dag.tasks):
             resources_str = backend_utils.get_task_resources_str(

sky/optimizer.py

@@ -14,6 +14,7 @@ from sky import clouds
 from sky import exceptions
 from sky import resources as resources_lib
 from sky import sky_logging
+from sky import skypilot_config
 from sky import task as task_lib
 from sky.adaptors import common as adaptors_common
 from sky.clouds import cloud as sky_cloud
@@ -1217,9 +1218,11 @@ def _check_specified_clouds(dag: 'dag_lib.Dag') -> None:
         clouds_to_check_again = list(clouds_need_recheck -
                                      global_disabled_clouds)
         if len(clouds_to_check_again) > 0:
-            sky_check.check_capability(sky_cloud.CloudCapability.COMPUTE,
-                                       quiet=True,
-                                       clouds=clouds_to_check_again)
+            sky_check.check_capability(
+                sky_cloud.CloudCapability.COMPUTE,
+                quiet=True,
+                clouds=clouds_to_check_again,
+                workspace=skypilot_config.get_active_workspace())
         enabled_clouds = sky_check.get_cached_enabled_clouds_or_refresh(
             capability=sky_cloud.CloudCapability.COMPUTE,
             raise_if_no_cloud_access=True)

sky/provision/fluidstack/instance.py

@@ -26,6 +26,7 @@ logger = sky_logging.init_logger(__name__)
 
 def get_internal_ip(node_info: Dict[str, Any]) -> None:
     node_info['internal_ip'] = node_info['ip_address']
+
     private_key_path, _ = auth.get_or_generate_keys()
     runner = command_runner.SSHCommandRunner(
         (node_info['ip_address'], 22),

sky/serve/server/core.py

@@ -14,6 +14,7 @@ from sky import backends
 from sky import exceptions
 from sky import execution
 from sky import sky_logging
+from sky import skypilot_config
 from sky import task as task_lib
 from sky.backends import backend_utils
 from sky.clouds.service_catalog import common as service_catalog_common
@@ -221,12 +222,14 @@ def up(
         # Since the controller may be shared among multiple users, launch the
         # controller with the API server's user hash.
         with common.with_server_user_hash():
-            controller_job_id, controller_handle = execution.launch(
-                task=controller_task,
-                cluster_name=controller_name,
-                retry_until_up=True,
-                _disable_controller_check=True,
-            )
+            with skypilot_config.local_active_workspace_ctx(
+                    constants.SKYPILOT_DEFAULT_WORKSPACE):
+                controller_job_id, controller_handle = execution.launch(
+                    task=controller_task,
+                    cluster_name=controller_name,
+                    retry_until_up=True,
+                    _disable_controller_check=True,
+                )
 
         style = colorama.Style
         fore = colorama.Fore

sky/server/html/token_page.html

@@ -49,6 +49,11 @@
             margin-bottom: 20px;
             color: #5f6368;
         }
+        .user-identifier {
+            font-size: 12px; /* Smaller font size */
+            color: #80868b;  /* Lighter color */
+            margin-bottom: 8px; /* Adjusted margin */
+        }
         .code-block {
             background-color: #f1f3f4;
             border: 1px solid #dadce0;
@@ -110,8 +115,8 @@
             </svg>
         </div>
         <h1>Sign in to SkyPilot CLI</h1>
+        <p class="user-identifier">USER_PLACEHOLDER</p>
         <p>You are seeing this page because a SkyPilot command requires authentication.</p>
-
         <p>Please copy the following token and paste it into your SkyPilot CLI prompt:</p>
         <div id="token-box" class="code-block">SKYPILOT_API_SERVER_USER_TOKEN_PLACEHOLDER</div>
         <button id="copy-btn" class="copy-button">Copy Token</button>

sky/server/requests/executor.py

@@ -228,6 +228,7 @@ def override_request_env_and_config(
     """Override the environment and SkyPilot config for a request."""
     original_env = os.environ.copy()
     os.environ.update(request_body.env_vars)
+    # Note: may be overridden by AuthProxyMiddleware.
     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)

sky/server/requests/payloads.py

@@ -88,6 +88,11 @@ class RequestBody(pydantic.BaseModel):
     using_remote_api_server: bool = False
     override_skypilot_config: Optional[Dict[str, Any]] = {}
 
+    # Allow extra fields in the request body, which is useful for backward
+    # compatibility, i.e., we can add new fields to the request body without
+    # breaking the existing old API server.
+    model_config = pydantic.ConfigDict(extra='allow')
+
     def __init__(self, **data):
         data['env_vars'] = data.get('env_vars', request_body_env_vars())
         usage_lib_entrypoint = usage_lib.messages.usage.entrypoint
@@ -126,6 +131,7 @@ class CheckBody(RequestBody):
     """The request body for the check endpoint."""
     clouds: Optional[Tuple[str, ...]] = None
     verbose: bool = False
+    workspace: Optional[str] = None
 
 
 class DagRequestBody(RequestBody):
@@ -525,3 +531,25 @@ class UploadZipFileResponse(pydantic.BaseModel):
     """The response body for the upload zip file endpoint."""
     status: str
     missing_chunks: Optional[List[str]] = None
+
+
+class EnabledCloudsBody(RequestBody):
+    """The request body for the enabled clouds endpoint."""
+    workspace: Optional[str] = None
+
+
+class UpdateWorkspaceBody(RequestBody):
+    """The request body for updating a specific workspace configuration."""
+    workspace_name: str = ''  # Will be set from path parameter
+    config: Dict[str, Any]
+
+
+class CreateWorkspaceBody(RequestBody):
+    """The request body for creating a new workspace."""
+    workspace_name: str = ''  # Will be set from path parameter
+    config: Dict[str, Any]
+
+
+class DeleteWorkspaceBody(RequestBody):
+    """The request body for deleting a workspace."""
+    workspace_name: str