huggingface-hub 0.29.0rc2__py3-none-any.whl → 1.1.3__py3-none-any.whl

huggingface_hub/inference/_providers/hyperbolic.py

@@ -1,7 +1,8 @@
 import base64
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional, Union
 
-from huggingface_hub.inference._common import _as_dict
+from huggingface_hub.hf_api import InferenceProviderMapping
+from huggingface_hub.inference._common import RequestParameters, _as_dict
 from huggingface_hub.inference._providers._common import BaseConversationalTask, TaskProviderHelper, filter_none
 
 
@@ -9,10 +10,13 @@ class HyperbolicTextToImageTask(TaskProviderHelper):
     def __init__(self):
         super().__init__(provider="hyperbolic", base_url="https://api.hyperbolic.xyz", task="text-to-image")
 
-    def _prepare_route(self, mapped_model: str) -> str:
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
         return "/v1/images/generations"
 
-    def _prepare_payload_as_dict(self, inputs: Any, parameters: Dict, mapped_model: str) -> Optional[Dict]:
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[dict]:
+        mapped_model = provider_mapping_info.provider_id
         parameters = filter_none(parameters)
         if "num_inference_steps" in parameters:
             parameters["steps"] = parameters.pop("num_inference_steps")
@@ -25,7 +29,7 @@ class HyperbolicTextToImageTask(TaskProviderHelper):
             parameters["height"] = 512
         return {"prompt": inputs, "model_name": mapped_model, **parameters}
 
-    def get_response(self, response: Union[bytes, Dict]) -> Any:
+    def get_response(self, response: Union[bytes, dict], request_params: Optional[RequestParameters] = None) -> Any:
         response_dict = _as_dict(response)
         return base64.b64decode(response_dict["images"][0]["image"])
 

huggingface_hub/inference/_providers/nebius.py

@@ -1,7 +1,8 @@
 import base64
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional, Union
 
-from huggingface_hub.inference._common import _as_dict
+from huggingface_hub.hf_api import InferenceProviderMapping
+from huggingface_hub.inference._common import RequestParameters, _as_dict
 from huggingface_hub.inference._providers._common import (
     BaseConversationalTask,
     BaseTextGenerationTask,
@@ -14,20 +15,44 @@ class NebiusTextGenerationTask(BaseTextGenerationTask):
     def __init__(self):
         super().__init__(provider="nebius", base_url="https://api.studio.nebius.ai")
 
+    def get_response(self, response: Union[bytes, dict], request_params: Optional[RequestParameters] = None) -> Any:
+        output = _as_dict(response)["choices"][0]
+        return {
+            "generated_text": output["text"],
+            "details": {
+                "finish_reason": output.get("finish_reason"),
+                "seed": output.get("seed"),
+            },
+        }
+
 
 class NebiusConversationalTask(BaseConversationalTask):
     def __init__(self):
         super().__init__(provider="nebius", base_url="https://api.studio.nebius.ai")
 
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[dict]:
+        payload = super()._prepare_payload_as_dict(inputs, parameters, provider_mapping_info)
+        response_format = parameters.get("response_format")
+        if isinstance(response_format, dict) and response_format.get("type") == "json_schema":
+            json_schema_details = response_format.get("json_schema")
+            if isinstance(json_schema_details, dict) and "schema" in json_schema_details:
+                payload["guided_json"] = json_schema_details["schema"]  # type: ignore [index]
+        return payload
+
 
 class NebiusTextToImageTask(TaskProviderHelper):
     def __init__(self):
         super().__init__(task="text-to-image", provider="nebius", base_url="https://api.studio.nebius.ai")
 
-    def _prepare_route(self, mapped_model: str) -> str:
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
         return "/v1/images/generations"
 
-    def _prepare_payload_as_dict(self, inputs: Any, parameters: Dict, mapped_model: str) -> Optional[Dict]:
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[dict]:
+        mapped_model = provider_mapping_info.provider_id
         parameters = filter_none(parameters)
         if "guidance_scale" in parameters:
             parameters.pop("guidance_scale")
@@ -36,6 +61,23 @@ class NebiusTextToImageTask(TaskProviderHelper):
 
         return {"prompt": inputs, **parameters, "model": mapped_model}
 
-    def get_response(self, response: Union[bytes, Dict]) -> Any:
+    def get_response(self, response: Union[bytes, dict], request_params: Optional[RequestParameters] = None) -> Any:
         response_dict = _as_dict(response)
         return base64.b64decode(response_dict["data"][0]["b64_json"])
+
+
+class NebiusFeatureExtractionTask(TaskProviderHelper):
+    def __init__(self):
+        super().__init__(task="feature-extraction", provider="nebius", base_url="https://api.studio.nebius.ai")
+
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
+        return "/v1/embeddings"
+
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[dict]:
+        return {"input": inputs, "model": provider_mapping_info.provider_id}
+
+    def get_response(self, response: Union[bytes, dict], request_params: Optional[RequestParameters] = None) -> Any:
+        embeddings = _as_dict(response)["data"]
+        return [embedding["embedding"] for embedding in embeddings]

huggingface_hub/inference/_providers/novita.py

@@ -1,26 +1,69 @@
+from typing import Any, Optional, Union
+
+from huggingface_hub.hf_api import InferenceProviderMapping
+from huggingface_hub.inference._common import RequestParameters, _as_dict
 from huggingface_hub.inference._providers._common import (
     BaseConversationalTask,
     BaseTextGenerationTask,
+    TaskProviderHelper,
+    filter_none,
 )
+from huggingface_hub.utils import get_session
 
 
 _PROVIDER = "novita"
-_BASE_URL = "https://api.novita.ai/v3/openai"
+_BASE_URL = "https://api.novita.ai"
 
 
 class NovitaTextGenerationTask(BaseTextGenerationTask):
     def __init__(self):
         super().__init__(provider=_PROVIDER, base_url=_BASE_URL)
 
-    def _prepare_route(self, mapped_model: str) -> str:
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
         # there is no v1/ route for novita
-        return "/completions"
+        return "/v3/openai/completions"
+
+    def get_response(self, response: Union[bytes, dict], request_params: Optional[RequestParameters] = None) -> Any:
+        output = _as_dict(response)["choices"][0]
+        return {
+            "generated_text": output["text"],
+            "details": {
+                "finish_reason": output.get("finish_reason"),
+                "seed": output.get("seed"),
+            },
+        }
 
 
 class NovitaConversationalTask(BaseConversationalTask):
     def __init__(self):
         super().__init__(provider=_PROVIDER, base_url=_BASE_URL)
 
-    def _prepare_route(self, mapped_model: str) -> str:
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
         # there is no v1/ route for novita
-        return "/chat/completions"
+        return "/v3/openai/chat/completions"
+
+
+class NovitaTextToVideoTask(TaskProviderHelper):
+    def __init__(self):
+        super().__init__(provider=_PROVIDER, base_url=_BASE_URL, task="text-to-video")
+
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
+        return f"/v3/hf/{mapped_model}"
+
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[dict]:
+        return {"prompt": inputs, **filter_none(parameters)}
+
+    def get_response(self, response: Union[bytes, dict], request_params: Optional[RequestParameters] = None) -> Any:
+        response_dict = _as_dict(response)
+        if not (
+            isinstance(response_dict, dict)
+            and "video" in response_dict
+            and isinstance(response_dict["video"], dict)
+            and "video_url" in response_dict["video"]
+        ):
+            raise ValueError("Expected response format: { 'video': { 'video_url': string } }")
+
+        video_url = response_dict["video"]["video_url"]
+        return get_session().get(video_url).content

huggingface_hub/inference/_providers/nscale.py

@@ -0,0 +1,44 @@
+import base64
+from typing import Any, Optional, Union
+
+from huggingface_hub.hf_api import InferenceProviderMapping
+from huggingface_hub.inference._common import RequestParameters, _as_dict
+
+from ._common import BaseConversationalTask, TaskProviderHelper, filter_none
+
+
+class NscaleConversationalTask(BaseConversationalTask):
+    def __init__(self):
+        super().__init__(provider="nscale", base_url="https://inference.api.nscale.com")
+
+
+class NscaleTextToImageTask(TaskProviderHelper):
+    def __init__(self):
+        super().__init__(provider="nscale", base_url="https://inference.api.nscale.com", task="text-to-image")
+
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
+        return "/v1/images/generations"
+
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[dict]:
+        mapped_model = provider_mapping_info.provider_id
+        # Combine all parameters except inputs and parameters
+        parameters = filter_none(parameters)
+        if "width" in parameters and "height" in parameters:
+            parameters["size"] = f"{parameters.pop('width')}x{parameters.pop('height')}"
+        if "num_inference_steps" in parameters:
+            parameters.pop("num_inference_steps")
+        if "cfg_scale" in parameters:
+            parameters.pop("cfg_scale")
+        payload = {
+            "response_format": "b64_json",
+            "prompt": inputs,
+            "model": mapped_model,
+            **parameters,
+        }
+        return payload
+
+    def get_response(self, response: Union[bytes, dict], request_params: Optional[RequestParameters] = None) -> Any:
+        response_dict = _as_dict(response)
+        return base64.b64decode(response_dict["data"][0]["b64_json"])

huggingface_hub/inference/_providers/openai.py

@@ -0,0 +1,25 @@
+from typing import Optional
+
+from huggingface_hub.hf_api import InferenceProviderMapping
+from huggingface_hub.inference._providers._common import BaseConversationalTask
+
+
+class OpenAIConversationalTask(BaseConversationalTask):
+    def __init__(self):
+        super().__init__(provider="openai", base_url="https://api.openai.com")
+
+    def _prepare_api_key(self, api_key: Optional[str]) -> str:
+        if api_key is None:
+            raise ValueError("You must provide an api_key to work with OpenAI API.")
+        if api_key.startswith("hf_"):
+            raise ValueError(
+                "OpenAI provider is not available through Hugging Face routing, please use your own OpenAI API key."
+            )
+        return api_key
+
+    def _prepare_mapping_info(self, model: Optional[str]) -> InferenceProviderMapping:
+        if model is None:
+            raise ValueError("Please provide an OpenAI model ID, e.g. `gpt-4o` or `o1`.")
+        return InferenceProviderMapping(
+            provider="openai", providerId=model, task="conversational", status="live", hf_model_id=model
+        )

huggingface_hub/inference/_providers/publicai.py

@@ -0,0 +1,6 @@
+from ._common import BaseConversationalTask
+
+
+class PublicAIConversationalTask(BaseConversationalTask):
+    def __init__(self):
+        super().__init__(provider="publicai", base_url="https://api.publicai.co")

huggingface_hub/inference/_providers/replicate.py

@@ -1,6 +1,7 @@
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional, Union
 
-from huggingface_hub.inference._common import _as_dict
+from huggingface_hub.hf_api import InferenceProviderMapping
+from huggingface_hub.inference._common import RequestParameters, _as_dict, _as_url
 from huggingface_hub.inference._providers._common import TaskProviderHelper, filter_none
 from huggingface_hub.utils import get_session
 
@@ -13,24 +14,27 @@ class ReplicateTask(TaskProviderHelper):
     def __init__(self, task: str):
         super().__init__(provider=_PROVIDER, base_url=_BASE_URL, task=task)
 
-    def _prepare_headers(self, headers: Dict, api_key: str) -> Dict:
+    def _prepare_headers(self, headers: dict, api_key: str) -> dict[str, Any]:
         headers = super()._prepare_headers(headers, api_key)
         headers["Prefer"] = "wait"
         return headers
 
-    def _prepare_route(self, mapped_model: str) -> str:
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
         if ":" in mapped_model:
             return "/v1/predictions"
         return f"/v1/models/{mapped_model}/predictions"
 
-    def _prepare_payload_as_dict(self, inputs: Any, parameters: Dict, mapped_model: str) -> Optional[Dict]:
-        payload: Dict[str, Any] = {"input": {"prompt": inputs, **filter_none(parameters)}}
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[dict]:
+        mapped_model = provider_mapping_info.provider_id
+        payload: dict[str, Any] = {"input": {"prompt": inputs, **filter_none(parameters)}}
         if ":" in mapped_model:
             version = mapped_model.split(":", 1)[1]
             payload["version"] = version
         return payload
 
-    def get_response(self, response: Union[bytes, Dict]) -> Any:
+    def get_response(self, response: Union[bytes, dict], request_params: Optional[RequestParameters] = None) -> Any:
         response_dict = _as_dict(response)
         if response_dict.get("output") is None:
             raise TimeoutError(
@@ -43,11 +47,44 @@ class ReplicateTask(TaskProviderHelper):
         return get_session().get(output_url).content
 
 
+class ReplicateTextToImageTask(ReplicateTask):
+    def __init__(self):
+        super().__init__("text-to-image")
+
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[dict]:
+        payload: dict = super()._prepare_payload_as_dict(inputs, parameters, provider_mapping_info)  # type: ignore[assignment]
+        if provider_mapping_info.adapter_weights_path is not None:
+            payload["input"]["lora_weights"] = f"https://huggingface.co/{provider_mapping_info.hf_model_id}"
+        return payload
+
+
 class ReplicateTextToSpeechTask(ReplicateTask):
     def __init__(self):
         super().__init__("text-to-speech")
 
-    def _prepare_payload_as_dict(self, inputs: Any, parameters: Dict, mapped_model: str) -> Optional[Dict]:
-        payload: Dict = super()._prepare_payload_as_dict(inputs, parameters, mapped_model)  # type: ignore[assignment]
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[dict]:
+        payload: dict = super()._prepare_payload_as_dict(inputs, parameters, provider_mapping_info)  # type: ignore[assignment]
         payload["input"]["text"] = payload["input"].pop("prompt")  # rename "prompt" to "text" for TTS
         return payload
+
+
+class ReplicateImageToImageTask(ReplicateTask):
+    def __init__(self):
+        super().__init__("image-to-image")
+
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[dict]:
+        image_url = _as_url(inputs, default_mime_type="image/jpeg")
+
+        payload: dict[str, Any] = {"input": {"input_image": image_url, **filter_none(parameters)}}
+
+        mapped_model = provider_mapping_info.provider_id
+        if ":" in mapped_model:
+            version = mapped_model.split(":", 1)[1]
+            payload["version"] = version
+        return payload

huggingface_hub/inference/_providers/sambanova.py

@@ -1,6 +1,42 @@
-from huggingface_hub.inference._providers._common import BaseConversationalTask
+from typing import Any, Optional, Union
+
+from huggingface_hub.hf_api import InferenceProviderMapping
+from huggingface_hub.inference._common import RequestParameters, _as_dict
+from huggingface_hub.inference._providers._common import BaseConversationalTask, TaskProviderHelper, filter_none
 
 
 class SambanovaConversationalTask(BaseConversationalTask):
     def __init__(self):
         super().__init__(provider="sambanova", base_url="https://api.sambanova.ai")
+
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[dict]:
+        response_format_config = parameters.get("response_format")
+        if isinstance(response_format_config, dict):
+            if response_format_config.get("type") == "json_schema":
+                json_schema_config = response_format_config.get("json_schema", {})
+                strict = json_schema_config.get("strict")
+                if isinstance(json_schema_config, dict) and (strict is True or strict is None):
+                    json_schema_config["strict"] = False
+
+        payload = super()._prepare_payload_as_dict(inputs, parameters, provider_mapping_info)
+        return payload
+
+
+class SambanovaFeatureExtractionTask(TaskProviderHelper):
+    def __init__(self):
+        super().__init__(provider="sambanova", base_url="https://api.sambanova.ai", task="feature-extraction")
+
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
+        return "/v1/embeddings"
+
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[dict]:
+        parameters = filter_none(parameters)
+        return {"input": inputs, "model": provider_mapping_info.provider_id, **parameters}
+
+    def get_response(self, response: Union[bytes, dict], request_params: Optional[RequestParameters] = None) -> Any:
+        embeddings = _as_dict(response)["data"]
+        return [embedding["embedding"] for embedding in embeddings]

huggingface_hub/inference/_providers/scaleway.py

@@ -0,0 +1,28 @@
+from typing import Any, Dict, Optional, Union
+
+from huggingface_hub.inference._common import RequestParameters, _as_dict
+
+from ._common import BaseConversationalTask, InferenceProviderMapping, TaskProviderHelper, filter_none
+
+
+class ScalewayConversationalTask(BaseConversationalTask):
+    def __init__(self):
+        super().__init__(provider="scaleway", base_url="https://api.scaleway.ai")
+
+
+class ScalewayFeatureExtractionTask(TaskProviderHelper):
+    def __init__(self):
+        super().__init__(provider="scaleway", base_url="https://api.scaleway.ai", task="feature-extraction")
+
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
+        return "/v1/embeddings"
+
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: Dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[Dict]:
+        parameters = filter_none(parameters)
+        return {"input": inputs, "model": provider_mapping_info.provider_id, **parameters}
+
+    def get_response(self, response: Union[bytes, Dict], request_params: Optional[RequestParameters] = None) -> Any:
+        embeddings = _as_dict(response)["data"]
+        return [embedding["embedding"] for embedding in embeddings]

huggingface_hub/inference/_providers/together.py

@@ -1,8 +1,9 @@
 import base64
 from abc import ABC
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional, Union
 
-from huggingface_hub.inference._common import _as_dict
+from huggingface_hub.hf_api import InferenceProviderMapping
+from huggingface_hub.inference._common import RequestParameters, _as_dict
 from huggingface_hub.inference._providers._common import (
     BaseConversationalTask,
     BaseTextGenerationTask,
@@ -21,7 +22,7 @@ class TogetherTask(TaskProviderHelper, ABC):
     def __init__(self, task: str):
         super().__init__(provider=_PROVIDER, base_url=_BASE_URL, task=task)
 
-    def _prepare_route(self, mapped_model: str) -> str:
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
         if self.task == "text-to-image":
             return "/v1/images/generations"
         elif self.task == "conversational":
@@ -35,17 +36,45 @@ class TogetherTextGenerationTask(BaseTextGenerationTask):
     def __init__(self):
         super().__init__(provider=_PROVIDER, base_url=_BASE_URL)
 
+    def get_response(self, response: Union[bytes, dict], request_params: Optional[RequestParameters] = None) -> Any:
+        output = _as_dict(response)["choices"][0]
+        return {
+            "generated_text": output["text"],
+            "details": {
+                "finish_reason": output.get("finish_reason"),
+                "seed": output.get("seed"),
+            },
+        }
+
 
 class TogetherConversationalTask(BaseConversationalTask):
     def __init__(self):
         super().__init__(provider=_PROVIDER, base_url=_BASE_URL)
 
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[dict]:
+        payload = super()._prepare_payload_as_dict(inputs, parameters, provider_mapping_info)
+        response_format = parameters.get("response_format")
+        if isinstance(response_format, dict) and response_format.get("type") == "json_schema":
+            json_schema_details = response_format.get("json_schema")
+            if isinstance(json_schema_details, dict) and "schema" in json_schema_details:
+                payload["response_format"] = {  # type: ignore [index]
+                    "type": "json_object",
+                    "schema": json_schema_details["schema"],
+                }
+
+        return payload
+
 
 class TogetherTextToImageTask(TogetherTask):
     def __init__(self):
         super().__init__("text-to-image")
 
-    def _prepare_payload_as_dict(self, inputs: Any, parameters: Dict, mapped_model: str) -> Optional[Dict]:
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[dict]:
+        mapped_model = provider_mapping_info.provider_id
         parameters = filter_none(parameters)
         if "num_inference_steps" in parameters:
             parameters["steps"] = parameters.pop("num_inference_steps")
@@ -54,6 +83,6 @@ class TogetherTextToImageTask(TogetherTask):
 
         return {"prompt": inputs, "response_format": "base64", **parameters, "model": mapped_model}
 
-    def get_response(self, response: Union[bytes, Dict]) -> Any:
+    def get_response(self, response: Union[bytes, dict], request_params: Optional[RequestParameters] = None) -> Any:
         response_dict = _as_dict(response)
         return base64.b64decode(response_dict["data"][0]["b64_json"])

huggingface_hub/inference/_providers/wavespeed.py

@@ -0,0 +1,138 @@
+import base64
+import time
+from abc import ABC
+from typing import Any, Optional, Union
+from urllib.parse import urlparse
+
+from huggingface_hub.hf_api import InferenceProviderMapping
+from huggingface_hub.inference._common import RequestParameters, _as_dict
+from huggingface_hub.inference._providers._common import TaskProviderHelper, filter_none
+from huggingface_hub.utils import get_session, hf_raise_for_status
+from huggingface_hub.utils.logging import get_logger
+
+
+logger = get_logger(__name__)
+
+# Polling interval (in seconds)
+_POLLING_INTERVAL = 0.5
+
+
+class WavespeedAITask(TaskProviderHelper, ABC):
+    def __init__(self, task: str):
+        super().__init__(provider="wavespeed", base_url="https://api.wavespeed.ai", task=task)
+
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
+        return f"/api/v3/{mapped_model}"
+
+    def get_response(
+        self,
+        response: Union[bytes, dict],
+        request_params: Optional[RequestParameters] = None,
+    ) -> Any:
+        response_dict = _as_dict(response)
+        data = response_dict.get("data", {})
+        result_path = data.get("urls", {}).get("get")
+
+        if not result_path:
+            raise ValueError("No result URL found in the response")
+        if request_params is None:
+            raise ValueError("A `RequestParameters` object should be provided to get responses with WaveSpeed AI.")
+
+        # Parse the request URL to determine base URL
+        parsed_url = urlparse(request_params.url)
+        # Add /wavespeed to base URL if going through HF router
+        if parsed_url.netloc == "router.huggingface.co":
+            base_url = f"{parsed_url.scheme}://{parsed_url.netloc}/wavespeed"
+        else:
+            base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
+
+        # Extract path from result_path URL
+        if isinstance(result_path, str):
+            result_url_path = urlparse(result_path).path
+        else:
+            result_url_path = result_path
+
+        result_url = f"{base_url}{result_url_path}"
+
+        logger.info("Processing request, polling for results...")
+
+        # Poll until task is completed
+        while True:
+            time.sleep(_POLLING_INTERVAL)
+            result_response = get_session().get(result_url, headers=request_params.headers)
+            hf_raise_for_status(result_response)
+
+            result = result_response.json()
+            task_result = result.get("data", {})
+            status = task_result.get("status")
+
+            if status == "completed":
+                # Get content from the first output URL
+                if not task_result.get("outputs") or len(task_result["outputs"]) == 0:
+                    raise ValueError("No output URL in completed response")
+
+                output_url = task_result["outputs"][0]
+                return get_session().get(output_url).content
+            elif status == "failed":
+                error_msg = task_result.get("error", "Task failed with no specific error message")
+                raise ValueError(f"WaveSpeed AI task failed: {error_msg}")
+            elif status in ["processing", "created"]:
+                continue
+            else:
+                raise ValueError(f"Unknown status: {status}")
+
+
+class WavespeedAITextToImageTask(WavespeedAITask):
+    def __init__(self):
+        super().__init__("text-to-image")
+
+    def _prepare_payload_as_dict(
+        self,
+        inputs: Any,
+        parameters: dict,
+        provider_mapping_info: InferenceProviderMapping,
+    ) -> Optional[dict]:
+        return {"prompt": inputs, **filter_none(parameters)}
+
+
+class WavespeedAITextToVideoTask(WavespeedAITextToImageTask):
+    def __init__(self):
+        WavespeedAITask.__init__(self, "text-to-video")
+
+
+class WavespeedAIImageToImageTask(WavespeedAITask):
+    def __init__(self):
+        super().__init__("image-to-image")
+
+    def _prepare_payload_as_dict(
+        self,
+        inputs: Any,
+        parameters: dict,
+        provider_mapping_info: InferenceProviderMapping,
+    ) -> Optional[dict]:
+        # Convert inputs to image (URL or base64)
+        if isinstance(inputs, str) and inputs.startswith(("http://", "https://")):
+            image = inputs
+        elif isinstance(inputs, str):
+            # If input is a file path, read it first
+            with open(inputs, "rb") as f:
+                file_content = f.read()
+            image_b64 = base64.b64encode(file_content).decode("utf-8")
+            image = f"data:image/jpeg;base64,{image_b64}"
+        else:
+            # If input is binary data
+            image_b64 = base64.b64encode(inputs).decode("utf-8")
+            image = f"data:image/jpeg;base64,{image_b64}"
+
+        # Extract prompt from parameters if present
+        prompt = parameters.pop("prompt", None)
+        payload = {"image": image, **filter_none(parameters)}
+        if prompt is not None:
+            payload["prompt"] = prompt
+
+        return payload
+
+
+class WavespeedAIImageToVideoTask(WavespeedAIImageToImageTask):
+    def __init__(self):
+        WavespeedAITask.__init__(self, "image-to-video")

huggingface_hub/inference/_providers/zai_org.py

@@ -0,0 +1,17 @@
+from typing import Any, Dict
+
+from huggingface_hub.inference._providers._common import BaseConversationalTask
+
+
+class ZaiConversationalTask(BaseConversationalTask):
+    def __init__(self):
+        super().__init__(provider="zai-org", base_url="https://api.z.ai")
+
+    def _prepare_headers(self, headers: Dict, api_key: str) -> Dict[str, Any]:
+        headers = super()._prepare_headers(headers, api_key)
+        headers["Accept-Language"] = "en-US,en"
+        headers["x-source-channel"] = "hugging_face"
+        return headers
+
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
+        return "/api/paas/v4/chat/completions"