dstack 0.18.43__py3-none-any.whl → 0.19.0__py3-none-any.whl

dstack/_internal/core/models/profiles.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union, overload
 
 from pydantic import Field, root_validator, validator
 from typing_extensions import Annotated, Literal
@@ -8,12 +8,9 @@ from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.common import CoreModel, Duration
 
 DEFAULT_RETRY_DURATION = 3600
-DEFAULT_POOL_NAME = "default-pool"
 
 DEFAULT_RUN_TERMINATION_IDLE_TIME = 5 * 60  # 5 minutes
-DEFAULT_POOL_TERMINATION_IDLE_TIME = 72 * 60 * 60  # 3 days
-
-DEFAULT_INSTANCE_RETRY_DURATION = 60 * 60 * 24  # 24h
+DEFAULT_FLEET_TERMINATION_IDLE_TIME = 72 * 60 * 60  # 3 days
 
 DEFAULT_STOP_DURATION = 300
 
@@ -34,6 +31,14 @@ class TerminationPolicy(str, Enum):
     DESTROY_AFTER_IDLE = "destroy-after-idle"
 
 
+@overload
+def parse_duration(v: None) -> None: ...
+
+
+@overload
+def parse_duration(v: Union[int, str]) -> int: ...
+
+
 def parse_duration(v: Optional[Union[int, str]]) -> Optional[int]:
     if v is None:
         return None
@@ -64,6 +69,8 @@ def parse_idle_duration(v: Optional[Union[int, str, bool]]) -> Optional[Union[st
     return parse_duration(v)
 
 
+# Deprecated in favor of ProfileRetry().
+# TODO: Remove when no longer referenced.
 class ProfileRetryPolicy(CoreModel):
     retry: Annotated[bool, Field(description="Whether to retry the run on failure or not")] = False
     duration: Annotated[
@@ -90,14 +97,15 @@ class RetryEvent(str, Enum):
 
 class ProfileRetry(CoreModel):
     on_events: Annotated[
-        List[RetryEvent],
+        Optional[List[RetryEvent]],
         Field(
             description=(
                 "The list of events that should be handled with retry."
-                " Supported events are `no-capacity`, `interruption`, and `error`"
+                " Supported events are `no-capacity`, `interruption`, and `error`."
+                " Omit to retry on all events"
             )
         ),
-    ]
+    ] = None
     duration: Annotated[
         Optional[Union[int, str]],
         Field(description="The maximum period of retrying the run, e.g., `4h` or `1d`"),
@@ -107,22 +115,56 @@ class ProfileRetry(CoreModel):
 
     @root_validator
     def _validate_fields(cls, values):
-        if "on_events" in values and len(values["on_events"]) == 0:
+        on_events = values.get("on_events", None)
+        if on_events is not None and len(values["on_events"]) == 0:
             raise ValueError("`on_events` cannot be empty")
         return values
 
 
+class UtilizationPolicy(CoreModel):
+    _min_time_window = "5m"
+
+    min_gpu_utilization: Annotated[
+        int,
+        Field(
+            description=(
+                "Minimum required GPU utilization, percent."
+                " If any GPU has utilization below specified value during the whole time window,"
+                " the run is terminated"
+            ),
+            ge=0,
+            le=100,
+        ),
+    ]
+    time_window: Annotated[
+        Union[int, str],
+        Field(
+            description=(
+                "The time window of metric samples taking into account to measure utilization"
+                f" (e.g., `30m`, `1h`). Minimum is `{_min_time_window}`"
+            )
+        ),
+    ]
+
+    @validator("time_window", pre=True)
+    def validate_time_window(cls, v: Union[int, str]) -> int:
+        v = parse_duration(v)
+        if v < parse_duration(cls._min_time_window):
+            raise ValueError(f"Minimum time_window is {cls._min_time_window}")
+        return v
+
+
 class ProfileParams(CoreModel):
     backends: Annotated[
         Optional[List[BackendType]],
         Field(description="The backends to consider for provisioning (e.g., `[aws, gcp]`)"),
-    ]
+    ] = None
     regions: Annotated[
         Optional[List[str]],
         Field(
             description="The regions to consider for provisioning (e.g., `[eu-west-1, us-west4, westeurope]`)"
         ),
-    ]
+    ] = None
     availability_zones: Annotated[
         Optional[List[str]],
         Field(
@@ -134,7 +176,7 @@ class ProfileParams(CoreModel):
         Field(
             description="The cloud-specific instance types to consider for provisioning (e.g., `[p3.8xlarge, n1-standard-4]`)"
         ),
-    ]
+    ] = None
     reservation: Annotated[
         Optional[str],
         Field(
@@ -143,17 +185,17 @@ class ProfileParams(CoreModel):
                 " Supports AWS Capacity Reservations and Capacity Blocks"
             )
         ),
-    ]
+    ] = None
     spot_policy: Annotated[
         Optional[SpotPolicy],
         Field(
             description="The policy for provisioning spot or on-demand instances: `spot`, `on-demand`, or `auto`. Defaults to `on-demand`"
         ),
-    ]
+    ] = None
     retry: Annotated[
         Optional[Union[ProfileRetry, bool]],
         Field(description="The policy for resubmitting the run. Defaults to `false`"),
-    ]
+    ] = None
     max_duration: Annotated[
         Optional[Union[Literal["off"], str, int, bool]],
         Field(
@@ -163,7 +205,7 @@ class ProfileParams(CoreModel):
                 " Use `off` for unlimited duration. Defaults to `off`"
             )
         ),
-    ]
+    ] = None
     stop_duration: Annotated[
         Optional[Union[Literal["off"], str, int, bool]],
         Field(
@@ -174,17 +216,17 @@ class ProfileParams(CoreModel):
                 " Use `off` for unlimited duration. Defaults to `5m`"
             )
         ),
-    ]
+    ] = None
     max_price: Annotated[
         Optional[float],
         Field(description="The maximum instance price per hour, in dollars", gt=0.0),
-    ]
+    ] = None
     creation_policy: Annotated[
         Optional[CreationPolicy],
         Field(
-            description="The policy for using instances from the pool. Defaults to `reuse-or-create`"
+            description="The policy for using instances from fleets. Defaults to `reuse-or-create`"
         ),
-    ]
+    ] = None
     idle_duration: Annotated[
         Optional[Union[Literal["off"], str, int, bool]],
         Field(
@@ -193,26 +235,27 @@ class ProfileParams(CoreModel):
                 " Defaults to `5m` for runs and `3d` for fleets. Use `off` for unlimited duration"
             )
         ),
-    ]
-    # Deprecated:
-    termination_policy: Annotated[
-        Optional[TerminationPolicy],
-        Field(
-            description="Deprecated in favor of `idle_duration`",
-        ),
-    ]
-    termination_idle_time: Annotated[
-        Optional[Union[str, int]],
-        Field(
-            description="Deprecated in favor of `idle_duration`",
-        ),
-    ]
-    # The name of the pool. If not set, dstack will use the default name
-    pool_name: Optional[str]
-    # The name of the instance
-    instance_name: Optional[str]
-    # The policy for resubmitting the run. Deprecated in favor of `retry`
-    retry_policy: Optional[ProfileRetryPolicy]
+    ] = None
+    utilization_policy: Annotated[
+        Optional[UtilizationPolicy],
+        Field(description="Run termination policy based on utilization"),
+    ] = None
+
+    # Deprecated and unused. Left for compatibility with 0.18 clients.
+    pool_name: Annotated[Optional[str], Field(exclude=True)] = None
+    instance_name: Annotated[Optional[str], Field(exclude=True)] = None
+    retry_policy: Annotated[Optional[ProfileRetryPolicy], Field(exclude=True)] = None
+    termination_policy: Annotated[Optional[TerminationPolicy], Field(exclude=True)] = None
+    termination_idle_time: Annotated[Optional[Union[str, int]], Field(exclude=True)] = None
+
+    class Config:
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]) -> None:
+            del schema["properties"]["pool_name"]
+            del schema["properties"]["instance_name"]
+            del schema["properties"]["retry_policy"]
+            del schema["properties"]["termination_policy"]
+            del schema["properties"]["termination_idle_time"]
 
     _validate_max_duration = validator("max_duration", pre=True, allow_reuse=True)(
         parse_max_duration
@@ -220,9 +263,6 @@ class ProfileParams(CoreModel):
     _validate_stop_duration = validator("stop_duration", pre=True, allow_reuse=True)(
         parse_stop_duration
     )
-    _validate_termination_idle_time = validator(
-        "termination_idle_time", pre=True, allow_reuse=True
-    )(parse_duration)
     _validate_idle_duration = validator("idle_duration", pre=True, allow_reuse=True)(
         parse_idle_duration
     )
@@ -232,11 +272,11 @@ class ProfileProps(CoreModel):
     name: Annotated[
         str,
         Field(
-            description="The name of the profile that can be passed as `--profile` to `dstack run`"
+            description="The name of the profile that can be passed as `--profile` to `dstack apply`"
         ),
     ]
     default: Annotated[
-        bool, Field(description="If set to true, `dstack run` will use this profile by default.")
+        bool, Field(description="If set to true, `dstack apply` will use this profile by default.")
     ] = False
 
 

dstack/_internal/core/models/projects.py

@@ -3,7 +3,7 @@ from typing import List, Optional
 
 from pydantic import UUID4
 
-from dstack._internal.core.models.backends import BackendInfo
+from dstack._internal.core.backends.models import BackendInfo
 from dstack._internal.core.models.common import CoreModel
 from dstack._internal.core.models.users import ProjectRole, User
 

dstack/_internal/core/models/repos/base.py

@@ -13,11 +13,6 @@ class RepoType(str, Enum):
     VIRTUAL = "virtual"
 
 
-class RepoProtocol(str, Enum):
-    SSH = "ssh"
-    HTTPS = "https"
-
-
 class BaseRepoInfo(CoreModel):
     repo_type: str
 

dstack/_internal/core/models/repos/local.py

@@ -26,7 +26,7 @@ class LocalRepo(Repo):
     Example:
 
     ```python
-    run = client.runs.submit(
+    run = client.runs.apply_configuration(
         configuration=...,
         repo=LocalRepo.from_dir("."), # Mount the current folder to the run
     )
@@ -41,10 +41,10 @@ class LocalRepo(Repo):
         Creates an instance of a local repo from a local path.
 
         Args:
-            repo_dir: The path to a local folder
+            repo_dir: The path to a local folder.
 
         Returns:
-            A local repo instance
+            A local repo instance.
         """
         return LocalRepo(repo_dir=repo_dir)
 

dstack/_internal/core/models/repos/remote.py

@@ -3,7 +3,7 @@ import re
 import subprocess
 import time
 from dataclasses import dataclass
-from typing import BinaryIO, Callable, Dict, Optional
+from typing import Annotated, Any, BinaryIO, Callable, Dict, Optional
 
 import git
 import pydantic
@@ -12,7 +12,7 @@ from typing_extensions import Literal
 
 from dstack._internal.core.errors import DstackError
 from dstack._internal.core.models.common import CoreModel
-from dstack._internal.core.models.repos.base import BaseRepoInfo, Repo, RepoProtocol
+from dstack._internal.core.models.repos.base import BaseRepoInfo, Repo
 from dstack._internal.utils.hash import get_sha256, slugify
 from dstack._internal.utils.path import PathLike
 from dstack._internal.utils.ssh import get_host_config
@@ -25,20 +25,34 @@ class RepoError(DstackError):
 
 
 class RemoteRepoCreds(CoreModel):
-    protocol: RepoProtocol  # TODO: remove in 0.19
     clone_url: str
     private_key: Optional[str]
     oauth_token: Optional[str]
 
+    # TODO: remove in 0.20. Left for compatibility with CLI <=0.18.44
+    protocol: Annotated[Optional[str], Field(exclude=True)] = None
+
+    class Config:
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]) -> None:
+            del schema["properties"]["protocol"]
+
 
 class RemoteRepoInfo(BaseRepoInfo):
     repo_type: Literal["remote"] = "remote"
     repo_name: str
 
-    # TODO: remove in 0.19
-    repo_host_name: str = ""
-    repo_port: Optional[int] = None
-    repo_user_name: str = ""
+    # TODO: remove in 0.20. Left for compatibility with CLI <=0.18.44
+    repo_host_name: Annotated[Optional[str], Field(exclude=True)] = None
+    repo_port: Annotated[Optional[int], Field(exclude=True)] = None
+    repo_user_name: Annotated[Optional[str], Field(exclude=True)] = None
+
+    class Config:
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]) -> None:
+            del schema["properties"]["repo_host_name"]
+            del schema["properties"]["repo_port"]
+            del schema["properties"]["repo_user_name"]
 
 
 class RemoteRunRepoData(RemoteRepoInfo):
@@ -84,7 +98,7 @@ class RemoteRepo(Repo):
     Finally, you can pass the repo object to the run:
 
     ```python
-    run = client.runs.submit(
+    run = client.runs.apply_configuration(
         configuration=...,
         repo=repo,
     )
@@ -100,10 +114,10 @@ class RemoteRepo(Repo):
         Creates an instance of a remote repo from a local path.
 
         Args:
-            repo_dir: The path to a local folder
+            repo_dir: The path to a local folder.
 
         Returns:
-            A remote repo instance
+            A remote repo instance.
         """
         return RemoteRepo(local_repo_dir=repo_dir)
 
@@ -115,12 +129,12 @@ class RemoteRepo(Repo):
         Creates an instance of a remote repo from a URL.
 
         Args:
-            repo_url: The URL of a remote Git repo
+            repo_url: The URL of a remote Git repo.
             repo_branch: The name of the remote branch. Must be specified if `hash` is not specified.
             repo_hash: The hash of the revision. Must be specified if `branch` is not specified.
 
         Returns:
-            A remote repo instance
+            A remote repo instance.
         """
         if repo_branch is None and repo_hash is None:
             raise ValueError("Either `repo_branch` or `repo_hash` must be specified.")

dstack/_internal/core/models/repos/virtual.py

@@ -30,7 +30,7 @@ class VirtualRepo(Repo):
     virtual_repo.add_file_from_package(package=some_package, path="requirements.txt")
     virtual_repo.add_file_from_package(package=some_package, path="train.py")
 
-    run = client.runs.submit(
+    run = client.runs.apply_configuration(
         configuration=...,
         repo=virtual_repo,
     )

dstack/_internal/core/models/resources.py

@@ -8,6 +8,7 @@ from typing_extensions import Annotated
 
 from dstack._internal.core.models.common import CoreModel
 from dstack._internal.utils.common import pretty_resources
+from dstack._internal.utils.json_schema import add_extra_schema_types
 from dstack._internal.utils.logging import get_logger
 
 logger = get_logger(__name__)
@@ -128,6 +129,22 @@ DEFAULT_GPU_COUNT = Range[int](min=1, max=1)
 
 
 class GPUSpec(CoreModel):
+    class Config:
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]):
+            add_extra_schema_types(
+                schema["properties"]["count"],
+                extra_types=[{"type": "integer"}, {"type": "string"}],
+            )
+            add_extra_schema_types(
+                schema["properties"]["memory"],
+                extra_types=[{"type": "integer"}, {"type": "string"}],
+            )
+            add_extra_schema_types(
+                schema["properties"]["total_memory"],
+                extra_types=[{"type": "integer"}, {"type": "string"}],
+            )
+
     vendor: Annotated[
         Optional[gpuhunt.AcceleratorVendor],
         Field(
@@ -233,6 +250,14 @@ class GPUSpec(CoreModel):
 
 
 class DiskSpec(CoreModel):
+    class Config:
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]):
+            add_extra_schema_types(
+                schema["properties"]["size"],
+                extra_types=[{"type": "integer"}, {"type": "string"}],
+            )
+
     size: Annotated[Range[Memory], Field(description="Disk size")]
 
     @classmethod
@@ -254,11 +279,26 @@ class ResourcesSpec(CoreModel):
     class Config:
         @staticmethod
         def schema_extra(schema: Dict[str, Any]):
-            schema.clear()
-            # replace strict schema with a more permissive one
-            ref_template = "#/definitions/ResourcesSpecRequest/definitions/{model}"
-            for field, value in ResourcesSpecSchema.schema(ref_template=ref_template).items():
-                schema[field] = value
+            add_extra_schema_types(
+                schema["properties"]["cpu"],
+                extra_types=[{"type": "integer"}, {"type": "string"}],
+            )
+            add_extra_schema_types(
+                schema["properties"]["memory"],
+                extra_types=[{"type": "integer"}, {"type": "string"}],
+            )
+            add_extra_schema_types(
+                schema["properties"]["shm_size"],
+                extra_types=[{"type": "integer"}, {"type": "string"}],
+            )
+            add_extra_schema_types(
+                schema["properties"]["gpu"],
+                extra_types=[{"type": "integer"}, {"type": "string"}],
+            )
+            add_extra_schema_types(
+                schema["properties"]["disk"],
+                extra_types=[{"type": "integer"}, {"type": "string"}],
+            )
 
     cpu: Annotated[Range[int], Field(description="The number of CPU cores")] = DEFAULT_CPU_COUNT
     memory: Annotated[Range[Memory], Field(description="The RAM size (e.g., `8GB`)")] = (
@@ -290,74 +330,3 @@ class ResourcesSpec(CoreModel):
             resources.update(disk_size=self.disk.size)
         res = pretty_resources(**resources)
         return res
-
-
-IntRangeLike = Union[Range[Union[int, str]], int, str]
-MemoryRangeLike = Union[Range[Union[Memory, float, int, str]], float, int, str]
-MemoryLike = Union[Memory, float, int, str]
-GPULike = Union[GPUSpec, "GPUSpecSchema", int, str]
-DiskLike = Union[DiskSpec, "DiskSpecSchema", float, int, str]
-ComputeCapabilityLike = Union[ComputeCapability, float, str]
-
-
-class GPUSpecSchema(CoreModel):
-    vendor: Annotated[
-        Optional[gpuhunt.AcceleratorVendor],
-        Field(
-            description="The vendor of the GPU/accelerator, one of: `nvidia`, `amd`, `google` (alias: `tpu`), `intel`"
-        ),
-    ] = None
-    name: Annotated[
-        Optional[Union[List[str], str]], Field(description="The GPU name or list of names")
-    ] = None
-    count: Annotated[IntRangeLike, Field(description="The number of GPUs")] = DEFAULT_GPU_COUNT
-    memory: Annotated[
-        Optional[MemoryRangeLike],
-        Field(
-            description="The RAM size (e.g., `16GB`). Can be set to a range (e.g. `16GB..`, or `16GB..80GB`)"
-        ),
-    ] = None
-    total_memory: Annotated[
-        Optional[MemoryRangeLike],
-        Field(
-            description="The total RAM size (e.g., `32GB`). Can be set to a range (e.g. `16GB..`, or `16GB..80GB`)"
-        ),
-    ] = None
-    compute_capability: Annotated[
-        Optional[ComputeCapabilityLike],
-        Field(description="The minimum compute capability of the GPU (e.g., `7.5`)"),
-    ] = None
-
-
-class DiskSpecSchema(CoreModel):
-    size: Annotated[
-        MemoryRangeLike,
-        Field(
-            description="The disk size. Can be set to a range (e.g., `100GB..` or `100GB..200GB`)"
-        ),
-    ]
-
-
-class ResourcesSpecSchema(CoreModel):
-    cpu: Annotated[Optional[IntRangeLike], Field(description="The number of CPU cores")] = (
-        DEFAULT_CPU_COUNT
-    )
-    memory: Annotated[
-        Optional[MemoryRangeLike],
-        Field(description="The RAM size (e.g., `8GB`)"),
-    ] = DEFAULT_MEMORY_SIZE
-    shm_size: Annotated[
-        Optional[MemoryLike],
-        Field(
-            description="The size of shared memory (e.g., `8GB`). "
-            "If you are using parallel communicating processes (e.g., dataloaders in PyTorch), "
-            "you may need to configure this"
-        ),
-    ] = None
-    gpu: Annotated[
-        Optional[GPULike],
-        Field(
-            description="The GPU requirements. Can be set to a number, a string (e.g. `A100`, `80GB:2`, etc.), or an object"
-        ),
-    ] = None
-    disk: Annotated[Optional[DiskLike], Field(description="The disk resources")] = DEFAULT_DISK

dstack/_internal/core/models/runs.py

@@ -20,9 +20,9 @@ from dstack._internal.core.models.profiles import (
     CreationPolicy,
     Profile,
     ProfileParams,
-    ProfileRetryPolicy,
     RetryEvent,
     SpotPolicy,
+    UtilizationPolicy,
 )
 from dstack._internal.core.models.repos import AnyRunRepoData
 from dstack._internal.core.models.resources import Memory, ResourcesSpec
@@ -114,6 +114,7 @@ class JobTerminationReason(str, Enum):
     ABORTED_BY_USER = "aborted_by_user"
     TERMINATED_BY_SERVER = "terminated_by_server"
     INACTIVITY_DURATION_EXCEEDED = "inactivity_duration_exceeded"
+    TERMINATED_DUE_TO_UTILIZATION_POLICY = "terminated_due_to_utilization_policy"
     # Set by the runner
     CONTAINER_EXITED_WITH_ERROR = "container_exited_with_error"
     PORTS_BINDING_FAILED = "ports_binding_failed"
@@ -135,6 +136,7 @@ class JobTerminationReason(str, Enum):
             self.ABORTED_BY_USER: JobStatus.ABORTED,
             self.TERMINATED_BY_SERVER: JobStatus.TERMINATED,
             self.INACTIVITY_DURATION_EXCEEDED: JobStatus.TERMINATED,
+            self.TERMINATED_DUE_TO_UTILIZATION_POLICY: JobStatus.TERMINATED,
             self.CONTAINER_EXITED_WITH_ERROR: JobStatus.FAILED,
             self.PORTS_BINDING_FAILED: JobStatus.FAILED,
             self.CREATING_CONTAINER_ERROR: JobStatus.FAILED,
@@ -175,6 +177,11 @@ class Gateway(CoreModel):
     options: dict = {}
 
 
+class JobSSHKey(CoreModel):
+    private: str
+    public: str
+
+
 class JobSpec(CoreModel):
     replica_num: int = 0  # default value for backward compatibility
     job_num: int
@@ -190,13 +197,12 @@ class JobSpec(CoreModel):
     single_branch: Optional[bool] = None
     max_duration: Optional[int]
     stop_duration: Optional[int] = None
+    utilization_policy: Optional[UtilizationPolicy] = None
     registry_auth: Optional[RegistryAuth]
     requirements: Requirements
     retry: Optional[Retry]
     volumes: Optional[List[MountPoint]] = None
-    # For backward compatibility with 0.18.x when retry_policy was required.
-    # TODO: remove in 0.19
-    retry_policy: ProfileRetryPolicy = ProfileRetryPolicy(retry=False)
+    ssh_key: Optional[JobSSHKey] = None
     working_dir: Optional[str]
 
 
@@ -302,7 +308,7 @@ class RunSpec(CoreModel):
     run_name: Annotated[
         Optional[str],
         Field(description="The run name. If not set, the run name is generated automatically."),
-    ]
+    ] = None
     repo_id: Annotated[
         Optional[str],
         Field(
@@ -312,15 +318,18 @@ class RunSpec(CoreModel):
                 " If not specified, a default virtual repo is used."
             )
         ),
-    ]
+    ] = None
     repo_data: Annotated[
         Optional[AnyRunRepoData],
         Field(
             discriminator="repo_type",
             description="The repo data such as the current branch and commit.",
         ),
-    ]
-    repo_code_hash: Annotated[Optional[str], Field(description="The hash of the repo diff")]
+    ] = None
+    repo_code_hash: Annotated[
+        Optional[str],
+        Field(description="The hash of the repo diff. Can be omitted if there is no repo diff."),
+    ] = None
     working_dir: Annotated[
         Optional[str],
         Field(
@@ -330,7 +339,7 @@ class RunSpec(CoreModel):
                 ' Defaults to `"."`.'
             )
         ),
-    ]
+    ] = None
     configuration_path: Annotated[
         Optional[str],
         Field(
@@ -339,9 +348,9 @@ class RunSpec(CoreModel):
                 " It can be omitted when using the programmatic API."
             )
         ),
-    ]
+    ] = None
     configuration: Annotated[AnyRunConfiguration, Field(discriminator="type")]
-    profile: Annotated[Optional[Profile], Field(description="The profile parameters")]
+    profile: Annotated[Optional[Profile], Field(description="The profile parameters")] = None
     ssh_key_pub: Annotated[
         str,
         Field(
@@ -448,9 +457,7 @@ class RunPlan(CoreModel):
     run_spec: RunSpec
     job_plans: List[JobPlan]
     current_resource: Optional[Run] = None
-    # Optional for backward-compatibility with 0.18.x servers
-    # TODO: make required in 0.19
-    action: Optional[ApplyAction] = None
+    action: ApplyAction
 
 
 class ApplyRunPlanInput(CoreModel):
@@ -466,11 +473,6 @@ class ApplyRunPlanInput(CoreModel):
     ] = None
 
 
-class PoolInstanceOffers(CoreModel):
-    pool_name: str
-    instances: List[InstanceOfferWithAvailability]
-
-
 def get_policy_map(spot_policy: Optional[SpotPolicy], default: SpotPolicy) -> Optional[bool]:
     """
     Map profile.spot_policy[SpotPolicy|None] to requirements.spot[bool|None]