dstack 0.19.25__py3-none-any.whl → 0.19.26__py3-none-any.whl

dstack/_internal/core/backends/tensordock/configurator.py

@@ -8,7 +8,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.tensordock import api_client
 from dstack._internal.core.backends.tensordock.backend import TensorDockBackend
 from dstack._internal.core.backends.tensordock.models import (
-    AnyTensorDockBackendConfig,
     TensorDockBackendConfig,
     TensorDockBackendConfigWithCreds,
     TensorDockConfig,
@@ -23,7 +22,12 @@ from dstack._internal.core.models.backends.base import (
 REGIONS = []
 
 
-class TensorDockConfigurator(Configurator):
+class TensorDockConfigurator(
+    Configurator[
+        TensorDockBackendConfig,
+        TensorDockBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.TENSORDOCK
     BACKEND_CLASS = TensorDockBackend
 
@@ -44,12 +48,14 @@ class TensorDockConfigurator(Configurator):
             auth=TensorDockCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyTensorDockBackendConfig:
+    def get_backend_config_with_creds(
+        self, record: BackendRecord
+    ) -> TensorDockBackendConfigWithCreds:
+        config = self._get_config(record)
+        return TensorDockBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> TensorDockBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return TensorDockBackendConfigWithCreds.__response__.parse_obj(config)
         return TensorDockBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> TensorDockBackend:

dstack/_internal/core/backends/vastai/configurator.py

@@ -8,7 +8,6 @@ from dstack._internal.core.backends.base.configurator import (
 from dstack._internal.core.backends.vastai import api_client
 from dstack._internal.core.backends.vastai.backend import VastAIBackend
 from dstack._internal.core.backends.vastai.models import (
-    AnyVastAIBackendConfig,
     VastAIBackendConfig,
     VastAIBackendConfigWithCreds,
     VastAIConfig,
@@ -23,7 +22,12 @@ from dstack._internal.core.models.backends.base import (
 REGIONS = []
 
 
-class VastAIConfigurator(Configurator):
+class VastAIConfigurator(
+    Configurator[
+        VastAIBackendConfig,
+        VastAIBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.VASTAI
     BACKEND_CLASS = VastAIBackend
 
@@ -42,12 +46,12 @@ class VastAIConfigurator(Configurator):
             auth=VastAICreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(
-        self, record: BackendRecord, include_creds: bool
-    ) -> AnyVastAIBackendConfig:
+    def get_backend_config_with_creds(self, record: BackendRecord) -> VastAIBackendConfigWithCreds:
+        config = self._get_config(record)
+        return VastAIBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> VastAIBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return VastAIBackendConfigWithCreds.__response__.parse_obj(config)
         return VastAIBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> VastAIBackend:

dstack/_internal/core/backends/vultr/configurator.py

@@ -23,7 +23,12 @@ from dstack._internal.core.models.backends.base import (
 REGIONS = []
 
 
-class VultrConfigurator(Configurator):
+class VultrConfigurator(
+    Configurator[
+        VultrBackendConfig,
+        VultrBackendConfigWithCreds,
+    ]
+):
     TYPE = BackendType.VULTR
     BACKEND_CLASS = VultrBackend
 
@@ -42,10 +47,12 @@ class VultrConfigurator(Configurator):
             auth=VultrCreds.parse_obj(config.creds).json(),
         )
 
-    def get_backend_config(self, record: BackendRecord, include_creds: bool) -> VultrBackendConfig:
+    def get_backend_config_with_creds(self, record: BackendRecord) -> VultrBackendConfigWithCreds:
+        config = self._get_config(record)
+        return VultrBackendConfigWithCreds.__response__.parse_obj(config)
+
+    def get_backend_config_without_creds(self, record: BackendRecord) -> VultrBackendConfig:
         config = self._get_config(record)
-        if include_creds:
-            return VultrBackendConfigWithCreds.__response__.parse_obj(config)
         return VultrBackendConfig.__response__.parse_obj(config)
 
     def get_backend(self, record: BackendRecord) -> VultrBackend:

dstack/_internal/core/compatibility/gpus.py

@@ -0,0 +1,13 @@
+from typing import Optional
+
+from dstack._internal.core.compatibility.runs import get_run_spec_excludes
+from dstack._internal.core.models.common import IncludeExcludeDictType
+from dstack._internal.server.schemas.gpus import ListGpusRequest
+
+
+def get_list_gpus_excludes(request: ListGpusRequest) -> Optional[IncludeExcludeDictType]:
+    list_gpus_excludes: IncludeExcludeDictType = {}
+    run_spec_excludes = get_run_spec_excludes(request.run_spec)
+    if run_spec_excludes is not None:
+        list_gpus_excludes["run_spec"] = run_spec_excludes
+    return list_gpus_excludes

dstack/_internal/core/compatibility/runs.py

@@ -136,6 +136,7 @@ def get_run_spec_excludes(run_spec: RunSpec) -> IncludeExcludeDictType:
         configuration_excludes["schedule"] = True
     if profile is not None and profile.schedule is None:
         profile_excludes.add("schedule")
+    configuration_excludes["repos"] = True
 
     if configuration_excludes:
         spec_excludes["configuration"] = configuration_excludes

dstack/_internal/core/models/common.py

@@ -102,12 +102,12 @@ class RegistryAuth(CoreModel):
         password (str): The password or access token
     """
 
-    class Config(CoreModel.Config):
-        frozen = True
-
     username: Annotated[str, Field(description="The username")]
     password: Annotated[str, Field(description="The password or access token")]
 
+    class Config(CoreModel.Config):
+        frozen = True
+
 
 class ApplyAction(str, Enum):
     CREATE = "create"  # resource is to be created or overridden

dstack/_internal/core/models/configurations.py

@@ -1,12 +1,13 @@
 import re
+import string
 from collections import Counter
 from enum import Enum
 from pathlib import PurePosixPath
-from typing import Any, Dict, List, Optional, Union
+from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
 import orjson
 from pydantic import Field, ValidationError, conint, constr, root_validator, validator
-from typing_extensions import Annotated, Literal
+from typing_extensions import Self
 
 from dstack._internal.core.errors import ConfigurationError
 from dstack._internal.core.models.common import CoreModel, Duration, RegistryAuth
@@ -83,6 +84,72 @@ class PortMapping(CoreModel):
         return PortMapping(local_port=local_port, container_port=int(container_port))
 
 
+class RepoSpec(CoreModel):
+    local_path: Annotated[
+        Optional[str],
+        Field(
+            description=(
+                "The path to the Git repo on the user's machine. Relative paths are resolved"
+                " relative to the parent directory of the the configuration file."
+                " Mutually exclusive with `url`"
+            )
+        ),
+    ] = None
+    url: Annotated[
+        Optional[str],
+        Field(description="The Git repo URL. Mutually exclusive with `local_path`"),
+    ] = None
+    branch: Annotated[
+        Optional[str],
+        Field(
+            description=(
+                "The repo branch. Defaults to the active branch for local paths"
+                " and the default branch for URLs"
+            )
+        ),
+    ] = None
+    hash: Annotated[
+        Optional[str],
+        Field(description="The commit hash"),
+    ] = None
+    # Not implemented, has no effect, hidden in the docs
+    path: str = DEFAULT_REPO_DIR
+
+    @classmethod
+    def parse(cls, v: str) -> Self:
+        is_url = False
+        parts = v.split(":")
+        if len(parts) > 1:
+            # Git repo, git@github.com:dstackai/dstack.git or https://github.com/dstackai/dstack
+            if "@" in parts[0] or parts[1].startswith("//"):
+                parts = [f"{parts[0]}:{parts[1]}", *parts[2:]]
+                is_url = True
+            # Windows path, e.g., `C:\path\to`, 'c:/path/to'
+            elif (
+                len(parts[0]) == 1
+                and parts[0] in string.ascii_letters
+                and parts[1][:1] in ["\\", "/"]
+            ):
+                parts = [f"{parts[0]}:{parts[1]}", *parts[2:]]
+        if len(parts) == 1:
+            if is_url:
+                return cls(url=parts[0])
+            return cls(local_path=parts[0])
+        if len(parts) == 2:
+            if is_url:
+                return cls(url=parts[0], path=parts[1])
+            return cls(local_path=parts[0], path=parts[1])
+        raise ValueError(f"Invalid repo: {v}")
+
+    @root_validator
+    def validate_local_path_or_url(cls, values):
+        if values["local_path"] and values["url"]:
+            raise ValueError("`local_path` and `url` are mutually exclusive")
+        if not values["local_path"] and not values["url"]:
+            raise ValueError("Either `local_path` or `url` must be specified")
+        return values
+
+
 class ScalingSpec(CoreModel):
     metric: Annotated[
         Literal["rps"],
@@ -221,7 +288,7 @@ class ProbeConfig(CoreModel):
         ),
     ] = None
     timeout: Annotated[
-        Optional[Union[int, str]],
+        Optional[int],
         Field(
             description=(
                 f"Maximum amount of time the HTTP request is allowed to take. Defaults to `{DEFAULT_PROBE_TIMEOUT}s`"
@@ -229,7 +296,7 @@ class ProbeConfig(CoreModel):
         ),
     ] = None
     interval: Annotated[
-        Optional[Union[int, str]],
+        Optional[int],
         Field(
             description=(
                 "Minimum amount of time between the end of one probe execution"
@@ -249,7 +316,19 @@ class ProbeConfig(CoreModel):
         ),
     ] = None
 
-    @validator("timeout")
+    class Config(CoreModel.Config):
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]):
+            add_extra_schema_types(
+                schema["properties"]["timeout"],
+                extra_types=[{"type": "string"}],
+            )
+            add_extra_schema_types(
+                schema["properties"]["interval"],
+                extra_types=[{"type": "string"}],
+            )
+
+    @validator("timeout", pre=True)
     def parse_timeout(cls, v: Optional[Union[int, str]]) -> Optional[int]:
         if v is None:
             return v
@@ -258,7 +337,7 @@ class ProbeConfig(CoreModel):
             raise ValueError(f"Probe timeout cannot be shorter than {MIN_PROBE_TIMEOUT}s")
         return parsed
 
-    @validator("interval")
+    @validator("interval", pre=True)
     def parse_interval(cls, v: Optional[Union[int, str]]) -> Optional[int]:
         if v is None:
             return v
@@ -373,22 +452,36 @@ class BaseRunConfiguration(CoreModel):
             ),
         ),
     ] = None
-    volumes: Annotated[
-        List[Union[MountPoint, str]], Field(description="The volumes mount points")
-    ] = []
+    volumes: Annotated[List[MountPoint], Field(description="The volumes mount points")] = []
     docker: Annotated[
         Optional[bool],
         Field(
             description="Use Docker inside the container. Mutually exclusive with `image`, `python`, and `nvcc`. Overrides `privileged`"
         ),
     ] = None
+    repos: Annotated[
+        list[RepoSpec],
+        Field(description="The list of Git repos"),
+    ] = []
     files: Annotated[
-        list[Union[FilePathMapping, str]],
+        list[FilePathMapping],
         Field(description="The local to container file path mappings"),
     ] = []
     # deprecated since 0.18.31; task, service -- no effect; dev-environment -- executed right before `init`
     setup: CommandsList = []
 
+    class Config(CoreModel.Config):
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]):
+            add_extra_schema_types(
+                schema["properties"]["volumes"]["items"],
+                extra_types=[{"type": "string"}],
+            )
+            add_extra_schema_types(
+                schema["properties"]["files"]["items"],
+                extra_types=[{"type": "string"}],
+            )
+
     @validator("python", pre=True, always=True)
     def convert_python(cls, v, values) -> Optional[PythonVersion]:
         if v is not None and values.get("image"):
@@ -413,18 +506,30 @@ class BaseRunConfiguration(CoreModel):
         #   but it's not possible to do so without breaking backwards compatibility.
         return v
 
-    @validator("volumes", each_item=True)
-    def convert_volumes(cls, v) -> MountPoint:
+    @validator("volumes", each_item=True, pre=True)
+    def convert_volumes(cls, v: Union[MountPoint, str]) -> MountPoint:
         if isinstance(v, str):
             return parse_mount_point(v)
         return v
 
-    @validator("files", each_item=True)
-    def convert_files(cls, v) -> FilePathMapping:
+    @validator("files", each_item=True, pre=True)
+    def convert_files(cls, v: Union[FilePathMapping, str]) -> FilePathMapping:
         if isinstance(v, str):
             return FilePathMapping.parse(v)
         return v
 
+    @validator("repos", pre=True, each_item=True)
+    def convert_repos(cls, v: Union[RepoSpec, str]) -> RepoSpec:
+        if isinstance(v, str):
+            return RepoSpec.parse(v)
+        return v
+
+    @validator("repos")
+    def validate_repos(cls, v) -> RepoSpec:
+        if len(v) > 1:
+            raise ValueError("A maximum of one repo is currently supported")
+        return v
+
     @validator("user")
     def validate_user(cls, v) -> Optional[str]:
         if v is None:
@@ -444,7 +549,7 @@ class BaseRunConfiguration(CoreModel):
         raise ValueError("The value must be `sh`, `bash`, or an absolute path")
 
 
-class BaseRunConfigurationWithPorts(BaseRunConfiguration):
+class ConfigurationWithPortsParams(CoreModel):
     ports: Annotated[
         List[Union[ValidPort, constr(regex=r"^(?:[0-9]+|\*):[0-9]+$"), PortMapping]],
         Field(description="Port numbers/mapping to expose"),
@@ -459,7 +564,7 @@ class BaseRunConfigurationWithPorts(BaseRunConfiguration):
         return v
 
 
-class BaseRunConfigurationWithCommands(BaseRunConfiguration):
+class ConfigurationWithCommandsParams(CoreModel):
     commands: Annotated[CommandsList, Field(description="The shell commands to run")] = []
 
     @root_validator
@@ -503,10 +608,25 @@ class DevEnvironmentConfigurationParams(CoreModel):
 
 
 class DevEnvironmentConfiguration(
-    ProfileParams, BaseRunConfigurationWithPorts, DevEnvironmentConfigurationParams
+    ProfileParams,
+    BaseRunConfiguration,
+    ConfigurationWithPortsParams,
+    DevEnvironmentConfigurationParams,
 ):
     type: Literal["dev-environment"] = "dev-environment"
 
+    class Config(ProfileParams.Config, BaseRunConfiguration.Config):
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]):
+            ProfileParams.Config.schema_extra(schema)
+            BaseRunConfiguration.Config.schema_extra(schema)
+
+    @validator("entrypoint")
+    def validate_entrypoint(cls, v: Optional[str]) -> Optional[str]:
+        if v is not None:
+            raise ValueError("entrypoint is not supported for dev-environment")
+        return v
+
 
 class TaskConfigurationParams(CoreModel):
     nodes: Annotated[int, Field(description="Number of nodes", ge=1)] = 1
@@ -514,12 +634,19 @@ class TaskConfigurationParams(CoreModel):
 
 class TaskConfiguration(
     ProfileParams,
-    BaseRunConfigurationWithCommands,
-    BaseRunConfigurationWithPorts,
+    BaseRunConfiguration,
+    ConfigurationWithCommandsParams,
+    ConfigurationWithPortsParams,
     TaskConfigurationParams,
 ):
     type: Literal["task"] = "task"
 
+    class Config(ProfileParams.Config, BaseRunConfiguration.Config):
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]):
+            ProfileParams.Config.schema_extra(schema)
+            BaseRunConfiguration.Config.schema_extra(schema)
+
 
 class ServiceConfigurationParams(CoreModel):
     port: Annotated[
@@ -547,7 +674,7 @@ class ServiceConfigurationParams(CoreModel):
         ),
     ] = STRIP_PREFIX_DEFAULT
     model: Annotated[
-        Optional[Union[AnyModel, str]],
+        Optional[AnyModel],
         Field(
             description=(
                 "Mapping of the model for the OpenAI-compatible endpoint provided by `dstack`."
@@ -578,6 +705,18 @@ class ServiceConfigurationParams(CoreModel):
         Field(description="List of probes used to determine job health"),
     ] = []
 
+    class Config(CoreModel.Config):
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]):
+            add_extra_schema_types(
+                schema["properties"]["replicas"],
+                extra_types=[{"type": "integer"}, {"type": "string"}],
+            )
+            add_extra_schema_types(
+                schema["properties"]["model"],
+                extra_types=[{"type": "string"}],
+            )
+
     @validator("port")
     def convert_port(cls, v) -> PortMapping:
         if isinstance(v, int):
@@ -586,7 +725,7 @@ class ServiceConfigurationParams(CoreModel):
             return PortMapping.parse(v)
         return v
 
-    @validator("model")
+    @validator("model", pre=True)
     def convert_model(cls, v: Optional[Union[AnyModel, str]]) -> Optional[AnyModel]:
         if isinstance(v, str):
             return OpenAIChatModel(type="chat", name=v, format="openai")
@@ -645,17 +784,23 @@ class ServiceConfigurationParams(CoreModel):
 
 
 class ServiceConfiguration(
-    ProfileParams, BaseRunConfigurationWithCommands, ServiceConfigurationParams
+    ProfileParams,
+    BaseRunConfiguration,
+    ConfigurationWithCommandsParams,
+    ServiceConfigurationParams,
 ):
     type: Literal["service"] = "service"
 
-    class Config(CoreModel.Config):
+    class Config(
+        ProfileParams.Config,
+        BaseRunConfiguration.Config,
+        ServiceConfigurationParams.Config,
+    ):
         @staticmethod
         def schema_extra(schema: Dict[str, Any]):
-            add_extra_schema_types(
-                schema["properties"]["replicas"],
-                extra_types=[{"type": "integer"}, {"type": "string"}],
-            )
+            ProfileParams.Config.schema_extra(schema)
+            BaseRunConfiguration.Config.schema_extra(schema)
+            ServiceConfigurationParams.Config.schema_extra(schema)
 
 
 AnyRunConfiguration = Union[DevEnvironmentConfiguration, TaskConfiguration, ServiceConfiguration]

dstack/_internal/core/models/files.py

@@ -28,7 +28,7 @@ class FilePathMapping(CoreModel):
         Field(
             description=(
                 "The path in the container. Relative paths are resolved relative to"
-                " the repo directory (`/workflow`)"
+                " the repo directory"
             )
         ),
     ]

dstack/_internal/core/models/fleets.py

@@ -224,7 +224,7 @@ class InstanceGroupParams(CoreModel):
         Field(description="The maximum instance price per hour, in dollars", gt=0.0),
     ] = None
     idle_duration: Annotated[
-        Optional[Union[Literal["off"], str, int]],
+        Optional[int],
         Field(
             description="Time to wait before terminating idle instances. Defaults to `5m` for runs and `3d` for fleets. Use `off` for unlimited duration"
         ),
@@ -243,6 +243,10 @@ class InstanceGroupParams(CoreModel):
                 schema["properties"]["nodes"],
                 extra_types=[{"type": "integer"}, {"type": "string"}],
             )
+            add_extra_schema_types(
+                schema["properties"]["idle_duration"],
+                extra_types=[{"type": "string"}],
+            )
 
     _validate_idle_duration = validator("idle_duration", pre=True, allow_reuse=True)(
         parse_idle_duration

dstack/_internal/core/models/profiles.py

@@ -9,6 +9,7 @@ from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.common import CoreModel, Duration
 from dstack._internal.utils.common import list_enum_values_for_annotation
 from dstack._internal.utils.cron import validate_cron
+from dstack._internal.utils.json_schema import add_extra_schema_types
 from dstack._internal.utils.json_utils import pydantic_orjson_dumps_with_indent
 from dstack._internal.utils.tags import tags_validator
 
@@ -61,15 +62,17 @@ def parse_duration(v: Optional[Union[int, str]]) -> Optional[int]:
     return Duration.parse(v)
 
 
-def parse_max_duration(v: Optional[Union[int, str, bool]]) -> Optional[Union[str, int]]:
+def parse_max_duration(v: Optional[Union[int, str, bool]]) -> Optional[Union[Literal["off"], int]]:
     return parse_off_duration(v)
 
 
-def parse_stop_duration(v: Optional[Union[int, str, bool]]) -> Optional[Union[str, int]]:
+def parse_stop_duration(
+    v: Optional[Union[int, str, bool]],
+) -> Optional[Union[Literal["off"], int]]:
     return parse_off_duration(v)
 
 
-def parse_off_duration(v: Optional[Union[int, str, bool]]) -> Optional[Union[str, int]]:
+def parse_off_duration(v: Optional[Union[int, str, bool]]) -> Optional[Union[Literal["off"], int]]:
     if v == "off" or v is False:
         return "off"
     if v is True:
@@ -77,7 +80,7 @@ def parse_off_duration(v: Optional[Union[int, str, bool]]) -> Optional[Union[str
     return parse_duration(v)
 
 
-def parse_idle_duration(v: Optional[Union[int, str]]) -> Optional[Union[str, int]]:
+def parse_idle_duration(v: Optional[Union[int, str]]) -> Optional[int]:
     if v == "off" or v == -1:
         return -1
     return parse_duration(v)
@@ -121,10 +124,18 @@ class ProfileRetry(CoreModel):
         ),
     ] = None
     duration: Annotated[
-        Optional[Union[int, str]],
+        Optional[int],
         Field(description="The maximum period of retrying the run, e.g., `4h` or `1d`"),
     ] = None
 
+    class Config(CoreModel.Config):
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]):
+            add_extra_schema_types(
+                schema["properties"]["duration"],
+                extra_types=[{"type": "string"}],
+            )
+
     _validate_duration = validator("duration", pre=True, allow_reuse=True)(parse_duration)
 
     @root_validator
@@ -151,7 +162,7 @@ class UtilizationPolicy(CoreModel):
         ),
     ]
     time_window: Annotated[
-        Union[int, str],
+        int,
         Field(
             description=(
                 "The time window of metric samples taking into account to measure utilization"
@@ -160,6 +171,14 @@ class UtilizationPolicy(CoreModel):
         ),
     ]
 
+    class Config(CoreModel.Config):
+        @staticmethod
+        def schema_extra(schema: Dict[str, Any]):
+            add_extra_schema_types(
+                schema["properties"]["time_window"],
+                extra_types=[{"type": "string"}],
+            )
+
     @validator("time_window", pre=True)
     def validate_time_window(cls, v: Union[int, str]) -> int:
         v = parse_duration(v)
@@ -247,7 +266,7 @@ class ProfileParams(CoreModel):
         Field(description="The policy for resubmitting the run. Defaults to `false`"),
     ] = None
     max_duration: Annotated[
-        Optional[Union[Literal["off"], str, int, bool]],
+        Optional[Union[Literal["off"], int]],
         Field(
             description=(
                 "The maximum duration of a run (e.g., `2h`, `1d`, etc)."
@@ -257,7 +276,7 @@ class ProfileParams(CoreModel):
         ),
     ] = None
     stop_duration: Annotated[
-        Optional[Union[Literal["off"], str, int, bool]],
+        Optional[Union[Literal["off"], int]],
         Field(
             description=(
                 "The maximum duration of a run graceful stopping."
@@ -282,7 +301,7 @@ class ProfileParams(CoreModel):
         ),
     ] = None
     idle_duration: Annotated[
-        Optional[Union[Literal["off"], str, int]],
+        Optional[int],
         Field(
             description=(
                 "Time to wait before terminating idle instances."
@@ -347,6 +366,18 @@ class ProfileParams(CoreModel):
             del schema["properties"]["retry_policy"]
             del schema["properties"]["termination_policy"]
             del schema["properties"]["termination_idle_time"]
+            add_extra_schema_types(
+                schema["properties"]["max_duration"],
+                extra_types=[{"type": "boolean"}, {"type": "string"}],
+            )
+            add_extra_schema_types(
+                schema["properties"]["stop_duration"],
+                extra_types=[{"type": "boolean"}, {"type": "string"}],
+            )
+            add_extra_schema_types(
+                schema["properties"]["idle_duration"],
+                extra_types=[{"type": "string"}],
+            )
 
     _validate_max_duration = validator("max_duration", pre=True, allow_reuse=True)(
         parse_max_duration
@@ -366,7 +397,7 @@ class ProfileProps(CoreModel):
         Field(
             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 apply` will use this profile by default.")
     ] = False
@@ -382,7 +413,6 @@ class ProfilesConfig(CoreModel):
     class Config(CoreModel.Config):
         json_loads = orjson.loads
         json_dumps = pydantic_orjson_dumps_with_indent
-
         schema_extra = {"$schema": "http://json-schema.org/draft-07/schema#"}
 
     def default(self) -> Optional[Profile]: