skypilot-nightly 1.0.0.dev20250905__py3-none-any.whl → 1.0.0.dev20251203__py3-none-any.whl

sky/clouds/lambda_cloud.py

@@ -59,7 +59,9 @@ class Lambda(clouds.Cloud):
 
     @classmethod
     def _unsupported_features_for_resources(
-        cls, resources: 'resources_lib.Resources'
+        cls,
+        resources: 'resources_lib.Resources',
+        region: Optional[str] = None,
     ) -> Dict[clouds.CloudImplementationFeatures, str]:
         del resources  # unused
         return cls._CLOUD_UNSUPPORTED_FEATURES
@@ -69,10 +71,15 @@ class Lambda(clouds.Cloud):
         return cls._MAX_CLUSTER_NAME_LEN_LIMIT
 
     @classmethod
-    def regions_with_offering(cls, instance_type: str,
-                              accelerators: Optional[Dict[str, int]],
-                              use_spot: bool, region: Optional[str],
-                              zone: Optional[str]) -> List[clouds.Region]:
+    def regions_with_offering(
+        cls,
+        instance_type: str,
+        accelerators: Optional[Dict[str, int]],
+        use_spot: bool,
+        region: Optional[str],
+        zone: Optional[str],
+        resources: Optional['resources_lib.Resources'] = None,
+    ) -> List[clouds.Region]:
         assert zone is None, 'Lambda does not support zones.'
         del accelerators, zone  # unused
         if use_spot:

sky/clouds/nebius.py

@@ -78,7 +78,9 @@ class Nebius(clouds.Cloud):
 
     @classmethod
     def _unsupported_features_for_resources(
-        cls, resources: 'resources_lib.Resources'
+        cls,
+        resources: 'resources_lib.Resources',
+        region: Optional[str] = None,
     ) -> Dict[clouds.CloudImplementationFeatures, str]:
         unsupported = cls._CLOUD_UNSUPPORTED_FEATURES.copy()
 
@@ -101,10 +103,15 @@ class Nebius(clouds.Cloud):
         return cls._MAX_CLUSTER_NAME_LEN_LIMIT
 
     @classmethod
-    def regions_with_offering(cls, instance_type: str,
-                              accelerators: Optional[Dict[str, int]],
-                              use_spot: bool, region: Optional[str],
-                              zone: Optional[str]) -> List[clouds.Region]:
+    def regions_with_offering(
+        cls,
+        instance_type: str,
+        accelerators: Optional[Dict[str, int]],
+        use_spot: bool,
+        region: Optional[str],
+        zone: Optional[str],
+        resources: Optional['resources_lib.Resources'] = None,
+    ) -> List[clouds.Region]:
         assert zone is None, 'Nebius does not support zones.'
         del accelerators, zone  # unused
         regions = catalog.get_region_zones_for_instance_type(
@@ -245,9 +252,12 @@ class Nebius(clouds.Cloud):
                 'filesystem_mount_tag': f'filesystem-skypilot-{i+1}'
             })
 
+        use_static_ip_address = skypilot_config.get_nested(
+            ('nebius', 'use_static_ip_address'), default_value=False)
         resources_vars: Dict[str, Any] = {
             'instance_type': resources.instance_type,
             'custom_resources': custom_resources,
+            'use_static_ip_address': use_static_ip_address,
             'region': region.name,
             'image_id': image_family,
             # Nebius does not support specific zones.
@@ -364,10 +374,10 @@ class Nebius(clouds.Cloud):
                       f'{_INDENT_PREFIX}  $ nebius --format json iam whoami|jq -r \'.user_profile.tenants[0].tenant_id\' > {nebius.tenant_id_path()} \n')  # pylint: disable=line-too-long
         if not nebius.is_token_or_cred_file_exist():
             return False, f'{token_cred_msg}'
-        sdk = nebius.sdk()
         tenant_id = nebius.get_tenant_id()
         if tenant_id is None:
             return False, f'{tenant_msg}'
+        sdk = nebius.sdk()
         try:
             service = nebius.iam().ProjectServiceClient(sdk)
             service.list(
@@ -445,9 +455,13 @@ class Nebius(clouds.Cloud):
         del workspace_config  # Unused
         sdk = nebius.sdk()
         profile_client = nebius.iam().ProfileServiceClient(sdk)
-        profile = nebius.sync_call(
-            profile_client.get(nebius.iam().GetProfileRequest(),
-                               timeout=nebius.READ_TIMEOUT))
+        try:
+            profile = nebius.sync_call(
+                profile_client.get(nebius.iam().GetProfileRequest(),
+                                   timeout=nebius.READ_TIMEOUT))
+        except Exception as e:
+            raise exceptions.CloudUserIdentityError(
+                f'Error getting Nebius profile: {e}')
         if profile.user_profile is not None:
             if profile.user_profile.attributes is None:
                 raise exceptions.CloudUserIdentityError(

sky/clouds/oci.py

@@ -28,6 +28,7 @@ from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 from sky import catalog
 from sky import clouds
 from sky import exceptions
+from sky.adaptors import common
 from sky.adaptors import oci as oci_adaptor
 from sky.clouds.utils import oci_utils
 from sky.provision.oci.query_utils import query_helper
@@ -68,7 +69,9 @@ class OCI(clouds.Cloud):
 
     @classmethod
     def _unsupported_features_for_resources(
-        cls, resources: 'resources_lib.Resources'
+        cls,
+        resources: 'resources_lib.Resources',
+        region: Optional[str] = None,
     ) -> Dict[clouds.CloudImplementationFeatures, str]:
         unsupported_features = {
             clouds.CloudImplementationFeatures.CLONE_DISK_FROM_CLUSTER:
@@ -95,10 +98,15 @@ class OCI(clouds.Cloud):
         return cls._MAX_CLUSTER_NAME_LEN_LIMIT
 
     @classmethod
-    def regions_with_offering(cls, instance_type: str,
-                              accelerators: Optional[Dict[str, int]],
-                              use_spot: bool, region: Optional[str],
-                              zone: Optional[str]) -> List[clouds.Region]:
+    def regions_with_offering(
+        cls,
+        instance_type: str,
+        accelerators: Optional[Dict[str, int]],
+        use_spot: bool,
+        region: Optional[str],
+        zone: Optional[str],
+        resources: Optional['resources_lib.Resources'] = None,
+    ) -> List[clouds.Region]:
         del accelerators  # unused
 
         regions = catalog.get_region_zones_for_instance_type(
@@ -454,13 +462,12 @@ class OCI(clouds.Cloud):
             f'{cls._INDENT_PREFIX}  region=us-sanjose-1\n'
             f'{cls._INDENT_PREFIX}  key_file=~/.oci/oci_api_key.pem')
 
-        try:
-            # pylint: disable=import-outside-toplevel,unused-import
-            import oci
-        except ImportError:
-            return False, ('`oci` is not installed. Install it with: '
-                           'pip install oci\n'
-                           f'{cls._INDENT_PREFIX}{short_credential_help_str}')
+        dependency_error_msg = (
+            '`oci` is not installed. Install it with: '
+            'pip install oci\n'
+            f'{cls._INDENT_PREFIX}{short_credential_help_str}')
+        if not common.can_import_modules(['oci']):
+            return False, dependency_error_msg
 
         conf_file = oci_adaptor.get_config_file()
 

sky/clouds/paperspace.py

@@ -60,7 +60,9 @@ class Paperspace(clouds.Cloud):
 
     @classmethod
     def _unsupported_features_for_resources(
-        cls, resources: 'resources_lib.Resources'
+        cls,
+        resources: 'resources_lib.Resources',
+        region: Optional[str] = None,
     ) -> Dict[clouds.CloudImplementationFeatures, str]:
         """The features not supported based on the resources provided.
 
@@ -86,6 +88,7 @@ class Paperspace(clouds.Cloud):
         use_spot: bool,
         region: Optional[str],
         zone: Optional[str],
+        resources: Optional['resources_lib.Resources'] = None,
     ) -> List[clouds.Region]:
         assert zone is None, 'Paperspace does not support zones.'
         del accelerators, zone  # unused

sky/clouds/primeintellect.py

@@ -0,0 +1,317 @@
+""" Prime Intellect Cloud. """
+import json
+import os
+import typing
+from typing import Dict, Iterator, List, Optional, Tuple, Union
+
+from sky import catalog
+from sky import clouds
+from sky.provision.primeintellect import utils
+from sky.utils import registry
+from sky.utils import resources_utils
+
+if typing.TYPE_CHECKING:
+    from sky import resources as resources_lib
+    from sky.utils import volume as volume_lib
+
+CredentialCheckResult = Tuple[bool, Optional[Union[str, Dict[str, str]]]]
+
+_CREDENTIAL_FILES = [
+    'config.json',
+]
+
+
+@registry.CLOUD_REGISTRY.register
+class PrimeIntellect(clouds.Cloud):
+    """Prime Intellect GPU Cloud"""
+    _REPR = 'PrimeIntellect'
+    _CLOUD_UNSUPPORTED_FEATURES = {
+        clouds.CloudImplementationFeatures.AUTOSTOP: 'Stopping not supported.',
+        clouds.CloudImplementationFeatures.AUTODOWN:
+            ('Auto down not supported yet.'),
+        clouds.CloudImplementationFeatures.STOP: 'Stopping not supported.',
+        clouds.CloudImplementationFeatures.MULTI_NODE:
+            ('Multi-node not supported yet.'),
+        clouds.CloudImplementationFeatures.CUSTOM_DISK_TIER:
+            ('Custom disk tier not supported yet.'),
+        clouds.CloudImplementationFeatures.CUSTOM_NETWORK_TIER:
+            ('Custom network tier not supported yet.'),
+        clouds.CloudImplementationFeatures.CUSTOM_MULTI_NETWORK:
+            ('Customized multiple network interfaces are not supported'),
+        clouds.CloudImplementationFeatures.IMAGE_ID:
+            ('Custom image not supported yet.'),
+        clouds.CloudImplementationFeatures.DOCKER_IMAGE:
+            ('Custom docker image not supported yet.'),
+    }
+    PROVISIONER_VERSION = clouds.ProvisionerVersion.SKYPILOT
+    STATUS_VERSION = clouds.StatusVersion.SKYPILOT
+    _MAX_CLUSTER_NAME_LEN_LIMIT = 120
+    _regions: List[clouds.Region] = []
+
+    @classmethod
+    def _cloud_unsupported_features(
+            cls) -> Dict[clouds.CloudImplementationFeatures, str]:
+        return cls._CLOUD_UNSUPPORTED_FEATURES
+
+    @classmethod
+    def _max_cluster_name_length(cls) -> Optional[int]:
+        return cls._MAX_CLUSTER_NAME_LEN_LIMIT
+
+    @classmethod
+    def regions_with_offering(
+        cls,
+        instance_type: str,
+        accelerators: Optional[Dict[str, int]],
+        use_spot: bool,
+        region: Optional[str],
+        zone: Optional[str],
+        resources: Optional['resources_lib.Resources'] = None,
+    ) -> List[clouds.Region]:
+        """Returns the regions that offer the specified resources."""
+        del accelerators
+        regions = catalog.get_region_zones_for_instance_type(
+            instance_type, use_spot, 'primeintellect')
+
+        if region is not None:
+            regions = [r for r in regions if r.name == region]
+        if zone is not None:
+            for r in regions:
+                assert r.zones is not None, r
+                r.set_zones([z for z in r.zones if z.name == zone])
+            regions = [r for r in regions if r.zones]
+        return regions
+
+    @classmethod
+    def get_vcpus_mem_from_instance_type(
+        cls,
+        instance_type: str,
+    ) -> Tuple[Optional[float], Optional[float]]:
+        """Returns the #vCPUs and memory that the instance type offers."""
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='primeintellect')
+
+    @classmethod
+    def zones_provision_loop(
+        cls,
+        *,
+        region: str,
+        num_nodes: int,
+        instance_type: str,
+        accelerators: Optional[Dict[str, int]] = None,
+        use_spot: bool = False,
+    ) -> Iterator[Optional[List['clouds.Zone']]]:
+        """Returns an iterator over zones for provisioning."""
+        regions = cls.regions_with_offering(instance_type,
+                                            accelerators,
+                                            use_spot,
+                                            region=region,
+                                            zone=None)
+        for r in regions:
+            assert r.zones is not None, r
+            yield r.zones
+
+    def instance_type_to_hourly_cost(self,
+                                     instance_type: str,
+                                     use_spot: bool,
+                                     region: Optional[str] = None,
+                                     zone: Optional[str] = None) -> float:
+        """Returns the cost, or the cheapest cost among all zones for spot."""
+        return catalog.get_hourly_cost(instance_type,
+                                       use_spot=use_spot,
+                                       region=region,
+                                       zone=zone,
+                                       clouds='primeintellect')
+
+    def accelerators_to_hourly_cost(self,
+                                    accelerators: Dict[str, int],
+                                    use_spot: bool,
+                                    region: Optional[str] = None,
+                                    zone: Optional[str] = None) -> float:
+        """Returns the cost, or the cheapest cost among all zones for spot."""
+        del accelerators, use_spot, region, zone  # Unused.
+        return 0.0
+
+    def get_egress_cost(self, num_gigabytes: float) -> float:
+        return 0.0
+
+    def is_same_cloud(self, other: clouds.Cloud) -> bool:
+        return isinstance(other, PrimeIntellect)
+
+    @classmethod
+    def get_default_instance_type(cls,
+                                  cpus: Optional[str] = None,
+                                  memory: Optional[str] = None,
+                                  disk_tier: Optional[
+                                      resources_utils.DiskTier] = None,
+                                  region: Optional[str] = None,
+                                  zone: Optional[str] = None) -> Optional[str]:
+        """Returns the default instance type for Prime Intellect."""
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 disk_tier=disk_tier,
+                                                 region=region,
+                                                 zone=zone,
+                                                 clouds='primeintellect')
+
+    @classmethod
+    def get_accelerators_from_instance_type(
+            cls, instance_type: str) -> Optional[Dict[str, Union[int, float]]]:
+        return catalog.get_accelerators_from_instance_type(
+            instance_type, clouds='primeintellect')
+
+    @classmethod
+    def get_zone_shell_cmd(cls) -> Optional[str]:
+        return None
+
+    def make_deploy_resources_variables(
+        self,
+        resources: 'resources_lib.Resources',
+        cluster_name: resources_utils.ClusterName,
+        region: 'clouds.Region',
+        zones: Optional[List['clouds.Zone']],
+        num_nodes: int,
+        dryrun: bool = False,
+        volume_mounts: Optional[List['volume_lib.VolumeMount']] = None
+    ) -> Dict[str, Optional[str]]:
+        del dryrun, cluster_name, num_nodes, volume_mounts
+        assert zones is not None, (region, zones)
+
+        resources = resources.assert_launchable()
+        acc_dict = self.get_accelerators_from_instance_type(
+            resources.instance_type)
+        if acc_dict is not None:
+            custom_resources = json.dumps(acc_dict, separators=(',', ':'))
+        else:
+            custom_resources = None
+
+        return {
+            'instance_type': resources.instance_type,
+            'custom_resources': custom_resources,
+            'region': region.name,
+            'zones': zones[0].name,
+            'availability_zone': zones[0].name,
+        }
+
+    def _get_feasible_launchable_resources(
+        self, resources: 'resources_lib.Resources'
+    ) -> 'resources_utils.FeasibleResources':
+        """Returns a list of feasible resources for the given resources."""
+        if resources.instance_type is not None:
+            assert resources.is_launchable(), resources
+            resources = resources.copy(accelerators=None)
+            return resources_utils.FeasibleResources([resources], [], None)
+
+        def _make(instance_list):
+            resource_list = []
+            for instance_type in instance_list:
+                r = resources.copy(
+                    cloud=PrimeIntellect(),
+                    instance_type=instance_type,
+                    accelerators=None,
+                    cpus=None,
+                )
+                resource_list.append(r)
+            return resource_list
+
+        # Currently, handle a filter on accelerators only.
+        accelerators = resources.accelerators
+        if accelerators is None:
+            default_instance_type = PrimeIntellect.get_default_instance_type(
+                cpus=resources.cpus,
+                memory=resources.memory,
+                disk_tier=resources.disk_tier)
+            if default_instance_type is None:
+                # TODO(pokgak): Add hints to all return values in this method
+                # to help users understand why the resources are not
+                # launchable.
+                return resources_utils.FeasibleResources([], [], None)
+            else:
+                return resources_utils.FeasibleResources(
+                    _make([default_instance_type]), [], None)
+
+        assert len(accelerators) == 1, resources
+        acc, acc_count = list(accelerators.items())[0]
+        (instance_list,
+         fuzzy_candidate_list) = catalog.get_instance_type_for_accelerator(
+             acc,
+             acc_count,
+             use_spot=resources.use_spot,
+             cpus=resources.cpus,
+             region=resources.region,
+             zone=resources.zone,
+             clouds='primeintellect')
+        if instance_list is None:
+            return resources_utils.FeasibleResources([], fuzzy_candidate_list,
+                                                     None)
+        return resources_utils.FeasibleResources(_make(instance_list),
+                                                 fuzzy_candidate_list, None)
+
+    @classmethod
+    def _check_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Verify that the user has valid credentials for Prime Intellect."""
+
+        primeintellect_config_file = '~/.prime/config.json'
+        if not os.path.isfile(os.path.expanduser(primeintellect_config_file)):
+            return (False, f'{primeintellect_config_file} does not exist.')
+
+        with open(os.path.expanduser(primeintellect_config_file),
+                  encoding='UTF-8') as f:
+            data = json.load(f)
+            api_key = data.get('api_key')
+            if not api_key:
+                print('API key is missing or empty')
+
+        client = utils.PrimeIntellectAPIClient()
+        try:
+            client.list_instances()
+        except utils.PrimeintellectAPIError as e:
+            if e.status_code == 403:
+                return False, (
+                    'Please check that your API key has the correct '
+                    'permissions, generate a new one at '
+                    'https://app.primeintellect.ai/dashboard/tokens, '
+                    'or run \'prime login\' to configure a new API key.')
+        return True, None
+
+    @classmethod
+    def _check_compute_credentials(cls) -> CredentialCheckResult:
+        """Checks if the user has access credentials to Prime Intellect's
+        compute service."""
+        return cls._check_credentials()
+
+    def get_credential_file_mounts(self) -> Dict[str, str]:
+        """Returns a dict of credential file paths to mount paths."""
+        return {
+            f'~/.prime/{filename}': f'~/.prime/{filename}'
+            for filename in _CREDENTIAL_FILES
+        }
+
+    @classmethod
+    def get_current_user_identity(cls) -> Optional[List[str]]:
+        return None
+
+    def instance_type_exists(self, instance_type: str) -> bool:
+        return catalog.instance_type_exists(instance_type, 'primeintellect')
+
+    def validate_region_zone(self, region: Optional[str], zone: Optional[str]):
+        return catalog.validate_region_zone(region,
+                                            zone,
+                                            clouds='primeintellect')
+
+    @classmethod
+    def _unsupported_features_for_resources(
+        cls,
+        resources: 'resources_lib.Resources',
+        region: Optional[str] = None,
+    ) -> Dict[clouds.CloudImplementationFeatures, str]:
+        """The features not supported based on the resources provided.
+
+        This method is used by check_features_are_supported() to check if the
+        cloud implementation supports all the requested features.
+
+        Returns:
+            A dict of {feature: reason} for the features not supported by the
+            cloud implementation.
+        """
+        del resources  # unused
+        return cls._CLOUD_UNSUPPORTED_FEATURES

sky/clouds/runpod.py

@@ -1,5 +1,7 @@
 """ RunPod Cloud. """
 
+from importlib import util as import_lib_util
+import os
 import typing
 from typing import Dict, Iterator, List, Optional, Tuple, Union
 
@@ -12,9 +14,7 @@ if typing.TYPE_CHECKING:
     from sky import resources as resources_lib
     from sky.utils import volume as volume_lib
 
-_CREDENTIAL_FILES = [
-    'config.toml',
-]
+_CREDENTIAL_FILE = 'config.toml'
 
 
 @registry.CLOUD_REGISTRY.register
@@ -53,7 +53,9 @@ class RunPod(clouds.Cloud):
 
     @classmethod
     def _unsupported_features_for_resources(
-        cls, resources: 'resources_lib.Resources'
+        cls,
+        resources: 'resources_lib.Resources',
+        region: Optional[str] = None,
     ) -> Dict[clouds.CloudImplementationFeatures, str]:
         """The features not supported based on the resources provided.
 
@@ -72,10 +74,15 @@ class RunPod(clouds.Cloud):
         return cls._MAX_CLUSTER_NAME_LEN_LIMIT
 
     @classmethod
-    def regions_with_offering(cls, instance_type: str,
-                              accelerators: Optional[Dict[str, int]],
-                              use_spot: bool, region: Optional[str],
-                              zone: Optional[str]) -> List[clouds.Region]:
+    def regions_with_offering(
+        cls,
+        instance_type: str,
+        accelerators: Optional[Dict[str, int]],
+        use_spot: bool,
+        region: Optional[str],
+        zone: Optional[str],
+        resources: Optional['resources_lib.Resources'] = None,
+    ) -> List[clouds.Region]:
         del accelerators  # unused
         regions = catalog.get_region_zones_for_instance_type(
             instance_type, use_spot, 'runpod')
@@ -193,7 +200,7 @@ class RunPod(clouds.Cloud):
             acc_dict)
 
         if resources.image_id is None:
-            image_id: Optional[str] = 'runpod/base:0.0.2'
+            image_id: Optional[str] = 'runpod/base:1.0.2-ubuntu2204'
         elif resources.extract_docker_image() is not None:
             image_id = resources.extract_docker_image()
         else:
@@ -285,30 +292,84 @@ class RunPod(clouds.Cloud):
 
     @classmethod
     def _check_credentials(cls) -> Tuple[bool, Optional[str]]:
-        """ Verify that the user has valid credentials for RunPod. """
+        """Verify that the user has valid credentials for RunPod. """
+        dependency_error_msg = ('Failed to import runpod or TOML parser. '
+                                'Install: pip install "skypilot[runpod]".')
+        try:
+            runpod_spec = import_lib_util.find_spec('runpod')
+            if runpod_spec is None:
+                return False, dependency_error_msg
+            # Prefer stdlib tomllib (Python 3.11+); fallback to tomli
+            tomllib_spec = import_lib_util.find_spec('tomllib')
+            tomli_spec = import_lib_util.find_spec('tomli')
+            if tomllib_spec is None and tomli_spec is None:
+                return False, dependency_error_msg
+        except ValueError:
+            # docstring of importlib_util.find_spec:
+            # First, sys.modules is checked to see if the module was alread
+            # imported.
+            # If so, then sys.modules[name].__spec__ is returned.
+            # If that happens to be set to None, then ValueError is raised.
+            return False, dependency_error_msg
+
+        valid, error = cls._check_runpod_credentials()
+        if not valid:
+            return False, (
+                f'{error} \n'  # First line is indented by 4 spaces
+                '    Credentials can be set up by running: \n'
+                f'        $ pip install runpod \n'
+                f'        $ runpod config\n'
+                '    For more information, see https://docs.skypilot.co/en/latest/getting-started/installation.html#runpod'  # pylint: disable=line-too-long
+            )
+
+        return True, None
+
+    @classmethod
+    def _check_runpod_credentials(cls, profile: str = 'default'):
+        """Checks if the credentials file exists and is valid."""
+        credential_file = os.path.expanduser(f'~/.runpod/{_CREDENTIAL_FILE}')
+        if not os.path.exists(credential_file):
+            return False, '~/.runpod/config.toml does not exist.'
+
+        # We don't need to import TOML parser if config.toml does not exist.
+        # When needed, prefer stdlib tomllib (py>=3.11); otherwise use tomli.
+        # TODO(andy): remove this fallback after dropping Python 3.10 support.
         try:
-            import runpod  # pylint: disable=import-outside-toplevel
-            valid, error = runpod.check_credentials()
+            try:
+                import tomllib as toml  # pylint: disable=import-outside-toplevel
+            except ModuleNotFoundError:  # py<3.11
+                import tomli as toml  # pylint: disable=import-outside-toplevel
+        except ModuleNotFoundError:
+            # Should never happen. We already installed proper dependencies for
+            # different Python versions in setup_files/dependencies.py.
+            return False, (
+                '~/.runpod/config.toml exists but no TOML parser is available. '
+                'Install tomli for Python < 3.11: pip install tomli.')
+
+        # Check for default api_key
+        try:
+            with open(credential_file, 'rb') as cred_file:
+                config = toml.load(cred_file)
 
-            if not valid:
+            if profile not in config:
                 return False, (
-                    f'{error} \n'  # First line is indented by 4 spaces
-                    '    Credentials can be set up by running: \n'
-                    f'        $ pip install runpod \n'
-                    f'        $ runpod config\n'
-                    '    For more information, see https://docs.skypilot.co/en/latest/getting-started/installation.html#runpod'  # pylint: disable=line-too-long
+                    f'~/.runpod/config.toml is missing {profile} profile.')
+
+            if 'api_key' not in config[profile]:
+                return (
+                    False,
+                    '~/.runpod/config.toml is missing '
+                    f'api_key for {profile} profile.',
                 )
 
-            return True, None
+        except (TypeError, ValueError):
+            return False, '~/.runpod/config.toml is not a valid TOML file.'
 
-        except ImportError:
-            return False, ('Failed to import runpod. '
-                           'To install, run: pip install skypilot[runpod]')
+        return True, None
 
     def get_credential_file_mounts(self) -> Dict[str, str]:
         return {
-            f'~/.runpod/{filename}': f'~/.runpod/{filename}'
-            for filename in _CREDENTIAL_FILES
+            f'~/.runpod/{_CREDENTIAL_FILE}': f'~/.runpod/{_CREDENTIAL_FILE}'
         }
 
     @classmethod