first draft of dynamic mapping

src/huggingface_hub/hf_api.py

@@ -132,56 +132,47 @@
 
 ExpandModelProperty_T = Literal[
     "author",
-    "baseModels",
     "cardData",
-    "childrenModelCount",
-    "config",
+    "citation",
     "createdAt",
+    "description",
     "disabled",
     "downloads",
     "downloadsAllTime",
     "gated",
-    "gguf",
-    "inference",
+    "inferenceProviderMapping",
     "lastModified",
-    "library_name",
     "likes",
-    "mask_token",
-    "model-index",
-    "pipeline_tag",
+    "paperswithcode_id",
     "private",
-    "safetensors",
+    "resourceGroup",
     "sha",
     "siblings",
-    "spaces",
     "tags",
-    "transformersInfo",
     "trendingScore",
-    "widgetData",
     "usedStorage",
-    "resourceGroup",
 ]
 
 ExpandDatasetProperty_T = Literal[
     "author",
     "cardData",
     "citation",
     "createdAt",
-    "disabled",
     "description",
+    "disabled",
     "downloads",
     "downloadsAllTime",
     "gated",
     "lastModified",
     "likes",
     "paperswithcode_id",
     "private",
-    "siblings",
+    "resourceGroup",
     "sha",
-    "trendingScore",
+    "siblings",
     "tags",
+    "trendingScore",
     "usedStorage",
-    "resourceGroup",
 ]
 
 ExpandSpaceProperty_T = Literal[
@@ -194,15 +185,15 @@
     "likes",
     "models",
     "private",
+    "resourceGroup",
     "runtime",
     "sdk",
-    "siblings",
     "sha",
+    "siblings",
     "subdomain",
     "tags",
     "trendingScore",
     "usedStorage",
-    "resourceGroup",
 ]
 
 USERNAME_PLACEHOLDER = "hf_user"

src/huggingface_hub/inference/_client.py

@@ -975,6 +975,7 @@ def chat_completion(
             headers=self.headers,
             model=model_id_or_url,
             api_key=self.token,
+            conversational=True,
         )
         data = self._inner_post(request_parameters, stream=stream)
 

src/huggingface_hub/inference/_common.py

@@ -49,6 +49,7 @@
     UnknownError,
     ValidationError,
 )
+from huggingface_hub.hf_api import HfApi
 
 from ..utils import (
     get_session,
@@ -98,10 +99,66 @@ def prepare_request(
         model: Optional[str],
         api_key: Optional[str],
         extra_payload: Optional[Dict[str, Any]] = None,
+        conversational: bool = False,
     ) -> RequestParameters: ...
     @abstractmethod
     def get_response(self, response: Union[bytes, Dict]) -> Any: ...
 
+    def map_model(self, model: Optional[str], chat_completion: bool = False) -> str:
+        """Default implementation for mapping model IDs to provider-specific IDs."""
+        if model is None:
+            raise ValueError(f"Please provide a model available on {self.provider}.")
+        return _get_provider_model_id(model, self.provider, self.task, chat_completion)
+
+
+#### Fetching Inference Providers model mapping
+_PROVIDER_MAPPINGS: Optional[Dict[str, Dict]] = None
+
+
+def _fetch_provider_mappings(model: str) -> Dict:
+    """
+    Fetch provider mappings for a model from the Hub.
+    """
+    try:
+        info = HfApi().model_info(model, expand=["inferenceProviderMapping"])
+        return info.get("inferenceProviderMapping", {})
+    except Exception as e:
+        raise ValueError(f"Failed to get provider mapping for model {model}: {e}")
+
+
+def _get_provider_model_id(
+    model: str, provider: str, task: Optional[str] = None, chat_completion: bool = False
+) -> str:
+    """
+    Map a model ID to a provider-specific ID.
+    """
+    if provider == "hf-inference":
+        return model
+
+    if task is None:
+        raise ValueError("task must be specified when using a third-party provider")
+
+    global _PROVIDER_MAPPINGS
+    if _PROVIDER_MAPPINGS is None:
+        _PROVIDER_MAPPINGS = _fetch_provider_mappings(model)
+        if not _PROVIDER_MAPPINGS:
+            logger.warning(f"No provider mappings found for model {model}")
+
+    provider_mapping = _PROVIDER_MAPPINGS.get(provider, {})
+    if not provider_mapping:
+        raise ValueError(f"Model {model} is not supported by provider {provider}")
+
+    provider_task = provider_mapping.get("task")
+    requested_task = "conversational" if task == "text-generation" and chat_completion else task
+
+    if provider_task != requested_task:
+        raise ValueError(
+            f"Model {model} is not supported for task {requested_task} and provider {provider}. "
+            f"Supported task: {provider_task}."
+        )
+
+    return provider_mapping.get("providerId", model)
+
 
 # Add dataclass for ModelStatus. We use this dataclass in get_model_status function.
 @dataclass

src/huggingface_hub/inference/_generated/_async_client.py

@@ -1015,6 +1015,7 @@ async def chat_completion(
             headers=self.headers,
             model=model_id_or_url,
             api_key=self.token,
+            conversational=True,
         )
         data = await self._inner_post(request_parameters, stream=stream)
 

src/huggingface_hub/inference/_providers/fal_ai.py

@@ -12,31 +12,6 @@
 
 BASE_URL = "https://fal.run"
 
-SUPPORTED_MODELS = {
-    "automatic-speech-recognition": {
-        "openai/whisper-large-v3": "fal-ai/whisper",
-    },
-    "text-to-image": {
-        "black-forest-labs/FLUX.1-dev": "fal-ai/flux/dev",
-        "black-forest-labs/FLUX.1-schnell": "fal-ai/flux/schnell",
-        "ByteDance/SDXL-Lightning": "fal-ai/lightning-models",
-        "fal/AuraFlow-v0.2": "fal-ai/aura-flow",
-        "Kwai-Kolors/Kolors": "fal-ai/kolors",
-        "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS": "fal-ai/pixart-sigma",
-        "playgroundai/playground-v2.5-1024px-aesthetic": "fal-ai/playground-v25",
-        "stabilityai/stable-diffusion-3-medium": "fal-ai/stable-diffusion-v3-medium",
-        "stabilityai/stable-diffusion-3.5-large": "fal-ai/stable-diffusion-v35-large",
-        "Warlord-K/Sana-1024": "fal-ai/sana",
-    },
-    "text-to-speech": {
-        "m-a-p/YuE-s1-7B-anneal-en-cot": "fal-ai/yue",
-    },
-    "text-to-video": {
-        "genmo/mochi-1-preview": "fal-ai/mochi-v1",
-        "tencent/HunyuanVideo": "fal-ai/hunyuan-video",
-    },
-}
-
 
 class FalAITask(TaskProviderHelper, ABC):
     """Base class for FalAI API tasks."""
@@ -53,15 +28,15 @@ def prepare_request(
         model: Optional[str],
         api_key: Optional[str],
         extra_payload: Optional[Dict[str, Any]] = None,
+        conversational: bool = False,
     ) -> RequestParameters:
         if api_key is None:
             api_key = get_token()
         if api_key is None:
             raise ValueError(
                 "You must provide an api_key to work with fal.ai API or log in with `huggingface-cli login`."
             )
-
-        mapped_model = self._map_model(model)
+        mapped_model = self.map_model(model, conversational=conversational)
         headers = {
             **build_hf_headers(token=api_key),
             **headers,
@@ -87,16 +62,6 @@ def prepare_request(
             headers=headers,
         )
 
-    def _map_model(self, model: Optional[str]) -> str:
-        if model is None:
-            raise ValueError("Please provide a model available on FalAI.")
-        if self.task not in SUPPORTED_MODELS:
-            raise ValueError(f"Task {self.task} not supported with FalAI.")
-        mapped_model = SUPPORTED_MODELS[self.task].get(model)
-        if mapped_model is None:
-            raise ValueError(f"Model {model} is not supported with FalAI for task {self.task}.")
-        return mapped_model
-
     @abstractmethod
     def _prepare_payload(self, inputs: Any, parameters: Dict[str, Any]) -> Dict[str, Any]: ...
 

src/huggingface_hub/inference/_providers/hf_inference.py

@@ -2,7 +2,12 @@
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 from huggingface_hub.constants import ENDPOINT
-from huggingface_hub.inference._common import RequestParameters, TaskProviderHelper, _b64_encode, _open_as_binary
+from huggingface_hub.inference._common import (
+    RequestParameters,
+    TaskProviderHelper,
+    _b64_encode,
+    _open_as_binary,
+)
 from huggingface_hub.utils import build_hf_headers, get_session, hf_raise_for_status
 
 
@@ -71,12 +76,15 @@ def prepare_request(
         model: Optional[str],
         api_key: Optional[str],
         extra_payload: Optional[Dict[str, Any]] = None,
+        conversational: bool = False,
     ) -> RequestParameters:
         if extra_payload is None:
             extra_payload = {}
-        mapped_model = self.map_model(model)
+        mapped_model = self.map_model(model, conversational=conversational)
         url = self.build_url(mapped_model)
-        data, json = self._prepare_payload(inputs, parameters=parameters, model=model, extra_payload=extra_payload)
+        data, json = self._prepare_payload(
+            inputs, parameters=parameters, model=mapped_model, extra_payload=extra_payload
+        )
         headers = self.prepare_headers(headers=headers, api_key=api_key)
 
         return RequestParameters(
@@ -88,9 +96,6 @@ def prepare_request(
             headers=headers,
         )
 
-    def map_model(self, model: Optional[str]) -> str:
-        return model if model is not None else get_recommended_model(self.task)
-
     def build_url(self, model: str) -> str:
         # hf-inference provider can handle URLs (e.g. Inference Endpoints or TGI deployment)
         if model.startswith(("http://", "https://")):
@@ -158,9 +163,10 @@ def prepare_request(
         model: Optional[str],
         api_key: Optional[str],
         extra_payload: Optional[Dict[str, Any]] = None,
+        conversational: bool = False,
     ) -> RequestParameters:
-        model = self.map_model(model)
-        payload_model = parameters.get("model") or model
+        mapped_model = self.map_model(model, conversational=conversational)
+        payload_model = parameters.get("model") or mapped_model
 
         if payload_model is None or payload_model.startswith(("http://", "https://")):
             payload_model = "tgi"  # use a random string if not provided
@@ -174,9 +180,9 @@ def prepare_request(
         headers = self.prepare_headers(headers=headers, api_key=api_key)
 
         return RequestParameters(
-            url=self.build_url(model),
+            url=self.build_url(mapped_model),
             task=self.task,
-            model=model,
+            model=mapped_model,
             json=json,
             data=None,
             headers=headers,

src/huggingface_hub/inference/_providers/replicate.py

@@ -10,26 +10,6 @@
 
 BASE_URL = "https://api.replicate.com"
 
-SUPPORTED_MODELS = {
-    "text-to-image": {
-        "black-forest-labs/FLUX.1-dev": "black-forest-labs/flux-dev",
-        "black-forest-labs/FLUX.1-schnell": "black-forest-labs/flux-schnell",
-        "ByteDance/Hyper-SD": "bytedance/hyper-flux-16step:382cf8959fb0f0d665b26e7e80b8d6dc3faaef1510f14ce017e8c732bb3d1eb7",
-        "ByteDance/SDXL-Lightning": "bytedance/sdxl-lightning-4step:5599ed30703defd1d160a25a63321b4dec97101d98b4674bcc56e41f62f35637",
-        "playgroundai/playground-v2.5-1024px-aesthetic": "playgroundai/playground-v2.5-1024px-aesthetic:a45f82a1382bed5c7aeb861dac7c7d191b0fdf74d8d57c4a0e6ed7d4d0bf7d24",
-        "stabilityai/stable-diffusion-3.5-large-turbo": "stability-ai/stable-diffusion-3.5-large-turbo",
-        "stabilityai/stable-diffusion-3.5-large": "stability-ai/stable-diffusion-3.5-large",
-        "stabilityai/stable-diffusion-3.5-medium": "stability-ai/stable-diffusion-3.5-medium",
-        "stabilityai/stable-diffusion-xl-base-1.0": "stability-ai/sdxl:7762fd07cf82c948538e41f63f77d685e02b063e37e496e96eefd46c929f9bdc",
-    },
-    "text-to-speech": {
-        "hexgrad/Kokoro-82M": "jaaari/kokoro-82m:f559560eb822dc509045f3921a1921234918b91739db4bf3daab2169b71c7a13",
-    },
-    "text-to-video": {
-        "genmo/mochi-1-preview": "genmoai/mochi-1:1944af04d098ef69bed7f9d335d102e652203f268ec4aaa2d836f6217217e460",
-    },
-}
-
 
 def _build_url(base_url: str, model: str) -> str:
     if ":" in model:
@@ -50,6 +30,7 @@ def prepare_request(
         model: Optional[str],
         api_key: Optional[str],
         extra_payload: Optional[Dict[str, Any]] = None,
+        conversational: bool = False,
     ) -> RequestParameters:
         if api_key is None:
             api_key = get_token()
@@ -65,7 +46,8 @@ def prepare_request(
         else:
             base_url = BASE_URL
             logger.info("Calling Replicate provider directly.")
-        mapped_model = self._map_model(model)
+
+        mapped_model = self.map_model(model, conversational=conversational)
         url = _build_url(base_url, mapped_model)
 
         headers = {
@@ -85,16 +67,6 @@ def prepare_request(
             headers=headers,
         )
 
-    def _map_model(self, model: Optional[str]) -> str:
-        if model is None:
-            raise ValueError("Please provide a model available on Replicate.")
-        if self.task not in SUPPORTED_MODELS:
-            raise ValueError(f"Task {self.task} not supported with Replicate.")
-        mapped_model = SUPPORTED_MODELS[self.task].get(model)
-        if mapped_model is None:
-            raise ValueError(f"Model {model} is not supported with Replicate for task {self.task}.")
-        return mapped_model
-
     def _prepare_payload(
         self,
         inputs: Any,