dstack 0.19.4rc3__py3-none-any.whl → 0.19.6rc1__py3-none-any.whl

dstack/_internal/core/backends/nebius/resources.py

@@ -2,9 +2,10 @@ import logging
 import time
 from collections import defaultdict
 from collections.abc import Container as ContainerT
-from collections.abc import Generator
+from collections.abc import Generator, Iterable, Sequence
 from contextlib import contextmanager
 from tempfile import NamedTemporaryFile
+from typing import Optional
 
 from nebius.aio.authorization.options import options_to_metadata
 from nebius.aio.operation import Operation as SDKOperation
@@ -40,7 +41,11 @@ from nebius.api.nebius.iam.v1 import (
 from nebius.api.nebius.vpc.v1 import ListSubnetsRequest, Subnet, SubnetServiceClient
 from nebius.sdk import SDK
 
-from dstack._internal.core.backends.nebius.models import NebiusServiceAccountCreds
+from dstack._internal.core.backends.base.configurator import raise_invalid_credentials_error
+from dstack._internal.core.backends.nebius.models import (
+    DEFAULT_PROJECT_NAME_PREFIX,
+    NebiusServiceAccountCreds,
+)
 from dstack._internal.core.errors import BackendError, NoCapacityError
 from dstack._internal.utils.event_loop import DaemonEventLoop
 from dstack._internal.utils.logging import get_logger
@@ -110,7 +115,37 @@ def wait_for_operation(
         LOOP.await_(op.update(timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD))
 
 
-def get_region_to_project_id_map(sdk: SDK) -> dict[str, str]:
+def get_region_to_project_id_map(
+    sdk: SDK, configured_regions: Optional[list[str]], configured_project_ids: Optional[list[str]]
+) -> dict[str, str]:
+    """Validate backend settings and build region->project_id map"""
+
+    projects = list_tenant_projects(sdk)
+    if configured_regions:
+        validate_regions(
+            configured=set(configured_regions), available={p.status.region for p in projects}
+        )
+    if configured_project_ids is not None:
+        return _get_region_to_configured_project_id_map(
+            projects, configured_project_ids, configured_regions
+        )
+    else:
+        return _get_region_to_default_project_id_map(projects, configured_regions)
+
+
+def validate_regions(configured: set[str], available: set[str]) -> None:
+    if invalid := set(configured) - available:
+        raise_invalid_credentials_error(
+            fields=[["regions"]],
+            details=(
+                f"Configured regions {invalid} do not exist in this Nebius tenancy."
+                " Omit `regions` to use all regions or select some of the available regions:"
+                f" {available}"
+            ),
+        )
+
+
+def list_tenant_projects(sdk: SDK) -> Sequence[Container]:
     tenants = LOOP.await_(
         TenantServiceClient(sdk).list(
             ListTenantsRequest(), timeout=REQUEST_TIMEOUT, metadata=REQUEST_MD
@@ -126,26 +161,72 @@ def get_region_to_project_id_map(sdk: SDK) -> dict[str, str]:
             metadata=REQUEST_MD,
         )
     )
+    return projects.items
+
+
+def _get_region_to_default_project_id_map(
+    all_tenant_projects: Iterable[Container], configured_regions: Optional[list[str]]
+) -> dict[str, str]:
     region_to_projects: defaultdict[str, list[Container]] = defaultdict(list)
-    for project in projects.items:
+    for project in all_tenant_projects:
         region_to_projects[project.status.region].append(project)
     region_to_project_id = {}
     for region, region_projects in region_to_projects.items():
+        if configured_regions and region not in configured_regions:
+            continue
         if len(region_projects) != 1:
-            # Currently, there can only be one project per region.
-            # This condition is implemented just in case Nebius suddenly allows more projects.
             region_projects = [
-                p for p in region_projects if p.metadata.name.startswith("default-project")
+                p
+                for p in region_projects
+                if p.metadata.name.startswith(DEFAULT_PROJECT_NAME_PREFIX)
             ]
             if len(region_projects) != 1:
-                logger.warning(
-                    "Could not find the default project in region %s, tenant %s", region, tenant_id
+                raise_invalid_credentials_error(
+                    ["regions"],
+                    (
+                        f"Could not find the default project in region {region}."
+                        " Consider setting the `projects` property in backend settings"
+                    ),
                 )
-                continue
         region_to_project_id[region] = region_projects[0].metadata.id
     return region_to_project_id
 
 
+def _get_region_to_configured_project_id_map(
+    all_tenant_projects: Iterable[Container],
+    configured_project_ids: list[str],
+    configured_regions: Optional[list[str]],
+) -> dict[str, str]:
+    project_id_to_project = {p.metadata.id: p for p in all_tenant_projects}
+    region_to_project_id = {}
+    for project_id in configured_project_ids:
+        project = project_id_to_project.get(project_id)
+        if project is None:
+            raise_invalid_credentials_error(
+                ["projects"],
+                f"Configured project ID {project_id!r} not found in this Nebius tenancy",
+            )
+        duplicate_project_id = region_to_project_id.get(project.status.region)
+        if duplicate_project_id:
+            raise_invalid_credentials_error(
+                ["projects"],
+                (
+                    f"Configured projects {project_id} and {duplicate_project_id}"
+                    f" both belong to the same region {project.status.region}."
+                    " Only one project per region is allowed"
+                ),
+            )
+        region_to_project_id[project.status.region] = project_id
+    if configured_regions:
+        # only filter by region after validating all project IDs
+        return {
+            region: project_id
+            for region, project_id in region_to_project_id.items()
+            if region in configured_regions
+        }
+    return region_to_project_id
+
+
 def get_default_subnet(sdk: SDK, project_id: str) -> Subnet:
     subnets = LOOP.await_(
         SubnetServiceClient(sdk).list(

dstack/_internal/core/backends/oci/auth.py

@@ -3,11 +3,10 @@ from typing_extensions import Any, Mapping
 
 from dstack._internal.core.backends.oci.exceptions import any_oci_exception
 from dstack._internal.core.backends.oci.models import AnyOCICreds, OCIDefaultCreds
-from dstack._internal.core.models.common import is_core_model_instance
 
 
 def get_client_config(creds: AnyOCICreds) -> Mapping[str, Any]:
-    if is_core_model_instance(creds, OCIDefaultCreds):
+    if isinstance(creds, OCIDefaultCreds):
         return oci.config.from_file(file_location=creds.file, profile_name=creds.profile)
     return creds.dict(exclude={"type"})
 

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

@@ -27,7 +27,6 @@ from dstack._internal.core.errors import ServerClientError
 from dstack._internal.core.models.backends.base import (
     BackendType,
 )
-from dstack._internal.core.models.common import is_core_model_instance
 
 # where dstack images are published
 SUPPORTED_REGIONS = frozenset(
@@ -48,7 +47,7 @@ class OCIConfigurator(Configurator):
     BACKEND_CLASS = OCIBackend
 
     def validate_config(self, config: OCIBackendConfigWithCreds, default_creds_enabled: bool):
-        if is_core_model_instance(config.creds, OCIDefaultCreds) and not default_creds_enabled:
+        if isinstance(config.creds, OCIDefaultCreds) and not default_creds_enabled:
             raise_invalid_credentials_error(
                 fields=[["creds"]],
                 details="Default credentials are forbidden by dstack settings",

dstack/_internal/core/backends/runpod/compute.py

@@ -260,7 +260,7 @@ class RunpodCompute(
 
 
 def _get_docker_args(authorized_keys: List[str]) -> str:
-    commands = get_docker_commands(authorized_keys, False)
+    commands = get_docker_commands(authorized_keys)
     command = " && ".join(commands)
     docker_args = {"cmd": [command], "entrypoint": ["/bin/sh", "-c"]}
     docker_args_escaped = json.dumps(json.dumps(docker_args)).strip('"')

dstack/_internal/core/errors.py

@@ -18,6 +18,10 @@ class ClientError(DstackError):
     pass
 
 
+class URLNotFoundError(ClientError):
+    pass
+
+
 class ServerClientErrorCode(str, enum.Enum):
     UNSPECIFIED_ERROR = "error"
     RESOURCE_EXISTS = "resource_exists"

dstack/_internal/core/models/common.py

@@ -1,10 +1,10 @@
 import re
 from enum import Enum
-from typing import Any, Type, TypeVar, Union
+from typing import Union
 
 from pydantic import Field
 from pydantic_duality import DualBaseModel
-from typing_extensions import Annotated, TypeGuard
+from typing_extensions import Annotated
 
 
 # DualBaseModel creates two classes for the model:
@@ -74,15 +74,3 @@ class ApplyAction(str, Enum):
 class NetworkMode(str, Enum):
     HOST = "host"
     BRIDGE = "bridge"
-
-
-_CM = TypeVar("_CM", bound=CoreModel)
-
-
-def is_core_model_instance(instance: Any, class_: Type[_CM]) -> TypeGuard[_CM]:
-    """
-    Implements isinstance check for CoreModel such that
-    models parsed with MyModel.__response__ pass the check against MyModel.
-    See https://github.com/dstackai/dstack/issues/1124
-    """
-    return isinstance(instance, class_) or isinstance(instance, class_.__response__)

dstack/_internal/core/models/configurations.py

@@ -1,6 +1,7 @@
 import re
 from collections import Counter
 from enum import Enum
+from pathlib import PurePosixPath
 from typing import Any, Dict, List, Optional, Union
 
 from pydantic import Field, ValidationError, conint, constr, root_validator, validator
@@ -210,6 +211,16 @@ class BaseRunConfiguration(CoreModel):
         Env,
         Field(description="The mapping or the list of environment variables"),
     ] = Env()
+    shell: Annotated[
+        Optional[str],
+        Field(
+            description=(
+                "The shell used to run commands."
+                " Allowed values are `sh`, `bash`, or an absolute path, e.g., `/usr/bin/zsh`."
+                " Defaults to `/bin/sh` if the `image` is specified, `/bin/bash` otherwise"
+            )
+        ),
+    ] = None
     # deprecated since 0.18.31; task, service -- no effect; dev-environment -- executed right before `init`
     setup: CommandsList = []
     resources: Annotated[
@@ -244,6 +255,17 @@ class BaseRunConfiguration(CoreModel):
         UnixUser.parse(v)
         return v
 
+    @validator("shell")
+    def validate_shell(cls, v) -> Optional[str]:
+        if v is None:
+            return None
+        if v in ["sh", "bash"]:
+            return v
+        path = PurePosixPath(v)
+        if path.is_absolute():
+            return v
+        raise ValueError("The value must be `sh`, `bash`, or an absolute path")
+
 
 class BaseRunConfigurationWithPorts(BaseRunConfiguration):
     ports: Annotated[
@@ -261,7 +283,7 @@ class BaseRunConfigurationWithPorts(BaseRunConfiguration):
 
 
 class BaseRunConfigurationWithCommands(BaseRunConfiguration):
-    commands: Annotated[CommandsList, Field(description="The bash commands to run")] = []
+    commands: Annotated[CommandsList, Field(description="The shell commands to run")] = []
 
     @root_validator
     def check_image_or_commands_present(cls, values):
@@ -276,7 +298,7 @@ class DevEnvironmentConfigurationParams(CoreModel):
         Field(description="The IDE to run. Supported values include `vscode` and `cursor`"),
     ]
     version: Annotated[Optional[str], Field(description="The version of the IDE")] = None
-    init: Annotated[CommandsList, Field(description="The bash commands to run on startup")] = []
+    init: Annotated[CommandsList, Field(description="The shell commands to run on startup")] = []
     inactivity_duration: Annotated[
         Optional[Union[Literal["off"], int, bool, str]],
         Field(

dstack/_internal/core/models/envs.py

@@ -4,7 +4,7 @@ from typing import Dict, Iterable, Iterator, List, Mapping, NamedTuple, Tuple, U
 from pydantic import BaseModel, Field, validator
 from typing_extensions import Annotated, Self
 
-from dstack._internal.core.models.common import CoreModel, is_core_model_instance
+from dstack._internal.core.models.common import CoreModel
 
 # VAR_NAME=VALUE, VAR_NAME=, or VAR_NAME
 _ENV_STRING_REGEX = r"^([a-zA-Z_][a-zA-Z0-9_]*)(=.*$|$)"
@@ -118,7 +118,7 @@ class Env(BaseModel):
         unresolved: List[str] = []
         dct: Dict[str, str] = {}
         for k, v in self.items():
-            if is_core_model_instance(v, EnvSentinel):
+            if isinstance(v, EnvSentinel):
                 unresolved.append(k)
             else:
                 # cast is required since TypeGuard is for positive cases only

dstack/_internal/core/models/fleets.py

@@ -21,6 +21,7 @@ from dstack._internal.core.models.profiles import (
 )
 from dstack._internal.core.models.resources import Range, ResourcesSpec
 from dstack._internal.utils.json_schema import add_extra_schema_types
+from dstack._internal.utils.tags import tags_validator
 
 
 class FleetStatus(str, Enum):
@@ -249,7 +250,18 @@ class FleetProps(CoreModel):
 
 
 class FleetConfiguration(InstanceGroupParams, FleetProps):
-    pass
+    tags: Annotated[
+        Optional[Dict[str, str]],
+        Field(
+            description=(
+                "The custom tags to associate with the resource."
+                " The tags are also propagated to the underlying backend resources."
+                " If there is a conflict with backend-level tags, does not override them"
+            )
+        ),
+    ] = None
+
+    _validate_tags = validator("tags", pre=True, allow_reuse=True)(tags_validator)
 
 
 class FleetSpec(CoreModel):
@@ -300,7 +312,26 @@ class FleetPlan(CoreModel):
     project_name: str
     user: str
     spec: FleetSpec
-    current_resource: Optional[Fleet]
+    effective_spec: Optional[FleetSpec] = None
+    current_resource: Optional[Fleet] = None
     offers: List[InstanceOfferWithAvailability]
     total_offers: int
-    max_offer_price: Optional[float]
+    max_offer_price: Optional[float] = None
+
+    def get_effective_spec(self) -> FleetSpec:
+        if self.effective_spec is not None:
+            return self.effective_spec
+        return self.spec
+
+
+class ApplyFleetPlanInput(CoreModel):
+    spec: FleetSpec
+    current_resource: Annotated[
+        Optional[Fleet],
+        Field(
+            description=(
+                "The expected current resource."
+                " If the resource has changed, the apply fails unless `force: true`."
+            )
+        ),
+    ] = None

dstack/_internal/core/models/gateways.py

@@ -1,12 +1,13 @@
 import datetime
 from enum import Enum
-from typing import Optional, Union
+from typing import Dict, Optional, Union
 
-from pydantic import Field
+from pydantic import Field, validator
 from typing_extensions import Annotated, Literal
 
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.common import CoreModel
+from dstack._internal.utils.tags import tags_validator
 
 
 class GatewayStatus(str, Enum):
@@ -57,6 +58,18 @@ class GatewayConfiguration(CoreModel):
         Optional[AnyGatewayCertificate],
         Field(description="The SSL certificate configuration. Defaults to `type: lets-encrypt`"),
     ] = LetsEncryptGatewayCertificate()
+    tags: Annotated[
+        Optional[Dict[str, str]],
+        Field(
+            description=(
+                "The custom tags to associate with the gateway."
+                " The tags are also propagated to the underlying backend resources."
+                " If there is a conflict with backend-level tags, does not override them"
+            )
+        ),
+    ] = None
+
+    _validate_tags = validator("tags", pre=True, allow_reuse=True)(tags_validator)
 
 
 class GatewaySpec(CoreModel):
@@ -88,7 +101,7 @@ class GatewayPlan(CoreModel):
     project_name: str
     user: str
     spec: GatewaySpec
-    current_resource: Optional[Gateway]
+    current_resource: Optional[Gateway] = None
 
 
 class GatewayComputeConfiguration(CoreModel):
@@ -98,7 +111,8 @@ class GatewayComputeConfiguration(CoreModel):
     region: str
     public_ip: bool
     ssh_key_pub: str
-    certificate: Optional[AnyGatewayCertificate]
+    certificate: Optional[AnyGatewayCertificate] = None
+    tags: Optional[Dict[str, str]] = None
 
 
 class GatewayProvisioningData(CoreModel):

dstack/_internal/core/models/instances.py

@@ -1,6 +1,6 @@
 import datetime
 from enum import Enum
-from typing import List, Optional
+from typing import Dict, List, Optional
 from uuid import UUID
 
 import gpuhunt
@@ -108,6 +108,7 @@ class InstanceConfiguration(CoreModel):
     placement_group_name: Optional[str] = None
     reservation: Optional[str] = None
     volumes: Optional[List[Volume]] = None
+    tags: Optional[Dict[str, str]] = None
 
     def get_public_keys(self) -> List[str]:
         return [ssh_key.public.strip() for ssh_key in self.ssh_keys]

dstack/_internal/core/models/profiles.py

@@ -6,6 +6,7 @@ from typing_extensions import Annotated, Literal
 
 from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.common import CoreModel, Duration
+from dstack._internal.utils.tags import tags_validator
 
 DEFAULT_RETRY_DURATION = 3600
 
@@ -243,6 +244,16 @@ class ProfileParams(CoreModel):
     fleets: Annotated[
         Optional[list[str]], Field(description="The fleets considered for reuse")
     ] = None
+    tags: Annotated[
+        Optional[Dict[str, str]],
+        Field(
+            description=(
+                "The custom tags to associate with the resource."
+                " The tags are also propagated to the underlying backend resources."
+                " If there is a conflict with backend-level tags, does not override them"
+            )
+        ),
+    ] = None
 
     # Deprecated and unused. Left for compatibility with 0.18 clients.
     pool_name: Annotated[Optional[str], Field(exclude=True)] = None
@@ -269,6 +280,7 @@ class ProfileParams(CoreModel):
     _validate_idle_duration = validator("idle_duration", pre=True, allow_reuse=True)(
         parse_idle_duration
     )
+    _validate_tags = validator("tags", pre=True, allow_reuse=True)(tags_validator)
 
 
 class ProfileProps(CoreModel):

dstack/_internal/core/models/runs.py

@@ -455,10 +455,16 @@ class RunPlan(CoreModel):
     project_name: str
     user: str
     run_spec: RunSpec
+    effective_run_spec: Optional[RunSpec] = None
     job_plans: List[JobPlan]
     current_resource: Optional[Run] = None
     action: ApplyAction
 
+    def get_effective_run_spec(self) -> RunSpec:
+        if self.effective_run_spec is not None:
+            return self.effective_run_spec
+        return self.run_spec
+
 
 class ApplyRunPlanInput(CoreModel):
     run_spec: RunSpec

dstack/_internal/core/models/secrets.py

@@ -6,4 +6,4 @@ class Secret(CoreModel):
     value: str
 
     def __str__(self) -> str:
-        return f'Secret(name="{self.name}", value={"*"*len(self.value)})'
+        return f'Secret(name="{self.name}", value={"*" * len(self.value)})'

dstack/_internal/core/models/volumes.py

@@ -2,7 +2,7 @@ import uuid
 from datetime import datetime
 from enum import Enum
 from pathlib import PurePosixPath
-from typing import List, Literal, Optional, Tuple, Union
+from typing import Dict, List, Literal, Optional, Tuple, Union
 
 from pydantic import Field, validator
 from typing_extensions import Annotated, Self
@@ -11,6 +11,7 @@ from dstack._internal.core.models.backends.base import BackendType
 from dstack._internal.core.models.common import CoreModel
 from dstack._internal.core.models.resources import Memory
 from dstack._internal.utils.common import get_or_error
+from dstack._internal.utils.tags import tags_validator
 
 
 class VolumeStatus(str, Enum):
@@ -43,6 +44,18 @@ class VolumeConfiguration(CoreModel):
         Optional[str],
         Field(description="The volume ID. Must be specified when registering external volumes"),
     ] = None
+    tags: Annotated[
+        Optional[Dict[str, str]],
+        Field(
+            description=(
+                "The custom tags to associate with the volume."
+                " The tags are also propagated to the underlying backend resources."
+                " If there is a conflict with backend-level tags, does not override them"
+            )
+        ),
+    ] = None
+
+    _validate_tags = validator("tags", pre=True, allow_reuse=True)(tags_validator)
 
     @property
     def size_gb(self) -> int:
@@ -91,11 +104,14 @@ class Volume(CoreModel):
     configuration: VolumeConfiguration
     external: bool
     created_at: datetime
+    last_processed_at: datetime
     status: VolumeStatus
     status_message: Optional[str] = None
     deleted: bool
+    deleted_at: Optional[datetime] = None
     volume_id: Optional[str] = None  # id of the volume in the cloud
     provisioning_data: Optional[VolumeProvisioningData] = None
+    cost: float = 0
     attachments: Optional[List[VolumeAttachment]] = None
     # attachment_data is deprecated in favor of attachments.
     # It's only set for volumes that were attached before attachments.

dstack/_internal/proxy/gateway/resources/nginx/service.jinja2

@@ -3,7 +3,7 @@ limit_req_zone {{ zone.key }} zone={{ zone.name }}:10m rate={{ zone.rpm }}r/m;
 {% endfor %}
 
 {% if replicas %}
-upstream {{ run_name }} {
+upstream {{ domain }}.upstream {
     {% for replica in replicas %}
     server unix:{{ replica.socket }};  # replica {{ replica.id }}
     {% endfor %}
@@ -37,7 +37,7 @@ server {
 
     {% if replicas %}
     location @websocket {
-        proxy_pass http://{{ run_name }};
+        proxy_pass http://{{ domain }}.upstream;
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header Host $host;
         proxy_http_version 1.1;
@@ -46,7 +46,7 @@ server {
         proxy_read_timeout 300s;
     }
     location @ {
-        proxy_pass http://{{ run_name }};
+        proxy_pass http://{{ domain }}.upstream;
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header Host $host;
         proxy_read_timeout 300s;

dstack/_internal/proxy/gateway/services/nginx.py

@@ -58,7 +58,6 @@ class LocationConfig(BaseModel):
 class ServiceConfig(SiteConfig):
     type: Literal["service"] = "service"
     project_name: str
-    run_name: str
     auth: bool
     client_max_body_size: int
     access_log_path: Path

dstack/_internal/proxy/gateway/services/registry.py

@@ -327,7 +327,6 @@ async def get_nginx_service_config(
         domain=service.domain_safe,
         https=service.https_safe,
         project_name=service.project_name,
-        run_name=service.run_name,
         auth=service.auth,
         client_max_body_size=service.client_max_body_size,
         access_log_path=ACCESS_LOG_PATH,

dstack/_internal/server/background/tasks/process_instances.py

@@ -17,11 +17,11 @@ from dstack._internal.core.backends import (
     BACKENDS_WITH_PLACEMENT_GROUPS_SUPPORT,
 )
 from dstack._internal.core.backends.base.compute import (
-    DSTACK_RUNNER_BINARY_PATH,
-    DSTACK_SHIM_BINARY_PATH,
-    DSTACK_WORKING_DIR,
     ComputeWithCreateInstanceSupport,
     ComputeWithPlacementGroupSupport,
+    get_dstack_runner_binary_path,
+    get_dstack_shim_binary_path,
+    get_dstack_working_dir,
     get_shim_env,
     get_shim_pre_start_commands,
 )
@@ -411,23 +411,26 @@ def _deploy_instance(
         except ValueError as e:
             raise ProvisioningError(f"Invalid Env: {e}") from e
         shim_envs.update(fleet_configuration_envs)
-        upload_envs(client, DSTACK_WORKING_DIR, shim_envs)
+        dstack_working_dir = get_dstack_working_dir()
+        dstack_shim_binary_path = get_dstack_shim_binary_path()
+        dstack_runner_binary_path = get_dstack_runner_binary_path()
+        upload_envs(client, dstack_working_dir, shim_envs)
         logger.debug("The dstack-shim environment variables have been installed")
 
         # Ensure we have fresh versions of host info.json and dstack-runner
-        remove_host_info_if_exists(client, DSTACK_WORKING_DIR)
-        remove_dstack_runner_if_exists(client, DSTACK_RUNNER_BINARY_PATH)
+        remove_host_info_if_exists(client, dstack_working_dir)
+        remove_dstack_runner_if_exists(client, dstack_runner_binary_path)
 
         # Run dstack-shim as a systemd service
         run_shim_as_systemd_service(
             client=client,
-            binary_path=DSTACK_SHIM_BINARY_PATH,
-            working_dir=DSTACK_WORKING_DIR,
+            binary_path=dstack_shim_binary_path,
+            working_dir=dstack_working_dir,
             dev=settings.DSTACK_VERSION is None,
         )
 
         # Get host info
-        host_info = get_host_info(client, DSTACK_WORKING_DIR)
+        host_info = get_host_info(client, dstack_working_dir)
         logger.debug("Received a host_info %s", host_info)
 
         raw_health = get_shim_healthcheck(client)