feat(inference): add DeepSeek remote inference provider (#6240)

# What does this PR do?

Adds a remote inference provider for **DeepSeek** (`remote::deepseek`).
DeepSeek is a widely used frontier lab (DeepSeek-V3 chat and DeepSeek-R1
reasoning models) that wasn't yet in the inference lineup — this lets
users run those models through the standard inference API.

DeepSeek exposes an OpenAI-compatible chat-completions API, so the
adapter extends the shared `OpenAIMixin` pointed at
`https://api.deepseek.com/v1`, authenticated via `DEEPSEEK_API_KEY` (or
the `deepseek_api_key` provider-data header). No new pip dependency is
required. DeepSeek does not offer an embeddings endpoint, so
`openai_embeddings` is unsupported (mirrors the Cerebras adapter).

## Changes
- `providers/remote/inference/deepseek/` — adapter
(`DeepSeekInferenceAdapter`), config (`DeepSeekImplConfig` +
provider-data validator), and `get_adapter_impl`.
- Registered `remote::deepseek` in `providers/registry/inference.py`.
- Unit tests in
`tests/unit/providers/inference/test_deepseek_config.py`.
- Regenerated provider docs (`docs/.../inference/remote_deepseek.mdx`)
via `scripts/provider_codegen.py`.

## Test Plan
- `pytest tests/unit/providers/inference/test_deepseek_config.py` → 6
passed (default/custom/env base URL, sample run config, provider-data
field, embeddings-unsupported).
- Provider resolves from the registry (`remote::deepseek`) and imports
cleanly.
- `mypy` and `ruff` clean on the new module.

Usage:
```yaml
providers:
  inference:
  - provider_id: deepseek
    provider_type: remote::deepseek
    config:
      api_key: ${env.DEEPSEEK_API_KEY}
```

---------

Signed-off-by: Nishchay Mahor <nishchaymahor@gmail.com>
Co-authored-by: Matthew Farrellee <matt@cs.wisc.edu>

Author: NishchayMahor

docs/docs/providers/inference/remote_deepseek.mdx

@@ -0,0 +1,44 @@
+---
+description: "DeepSeek inference provider for accessing DeepSeek models via the DeepSeek API."
+sidebar_label: Remote - Deepseek
+title: remote::deepseek
+---
+
+# remote::deepseek
+
+## Description
+
+DeepSeek inference provider for accessing DeepSeek models via the DeepSeek API.
+
+## Configuration
+
+| Field | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `allowed_models` | `list[str] \| None` | No |  | List of models that should be registered with the model registry. If None, all models are allowed. |
+| `refresh_models` | `bool` | No | False | Whether to refresh models periodically from the provider |
+| `api_key` | `SecretStr \| None` | No |  | Authentication credential for the provider |
+| `network` | `NetworkConfig \| None` | No |  | Network configuration including TLS, proxy, and timeout settings. |
+| `network.tls` | `TLSConfig \| None` | No |  | TLS/SSL configuration for secure connections. |
+| `network.tls.verify` | `bool \| Path` | No | True | Whether to verify TLS certificates. Can be a boolean or a path to a CA certificate file. |
+| `network.tls.min_version` | `Literal[TLSv1.2, TLSv1.3] \| None` | No |  | Minimum TLS version to use. Defaults to system default if not specified. |
+| `network.tls.ciphers` | `list[str] \| None` | No |  | List of allowed cipher suites (e.g., ['ECDHE+AESGCM', 'DHE+AESGCM']). |
+| `network.tls.client_cert` | `Path \| None` | No |  | Path to client certificate file for mTLS authentication. |
+| `network.tls.client_key` | `Path \| None` | No |  | Path to client private key file for mTLS authentication. |
+| `network.proxy` | `ProxyConfig \| None` | No |  | Proxy configuration for HTTP connections. |
+| `network.proxy.url` | `HttpUrl \| None` | No |  | Single proxy URL for all connections (e.g., 'http://proxy.example.com:8080'). |
+| `network.proxy.http` | `HttpUrl \| None` | No |  | Proxy URL for HTTP connections. |
+| `network.proxy.https` | `HttpUrl \| None` | No |  | Proxy URL for HTTPS connections. |
+| `network.proxy.cacert` | `Path \| None` | No |  | Path to CA certificate file for verifying the proxy's certificate. Required for proxies in interception mode. |
+| `network.proxy.no_proxy` | `list[str] \| None` | No |  | List of hosts that should bypass the proxy (e.g., ['localhost', '127.0.0.1', '.internal.corp']). |
+| `network.timeout` | `float \| TimeoutConfig \| None` | No |  | Timeout configuration. Can be a float (for both connect and read) or a TimeoutConfig object with separate connect and read timeouts. |
+| `network.timeout.connect` | `float \| None` | No |  | Connection timeout in seconds. |
+| `network.timeout.read` | `float \| None` | No |  | Read timeout in seconds. |
+| `network.headers` | `dict[str, str] \| None` | No |  | Additional HTTP headers to include in all requests. |
+| `base_url` | `HttpUrl \| None` | No | https://api.deepseek.com/v1 | Base URL for the DeepSeek API |
+
+## Sample Configuration
+
+```yaml
+base_url: https://api.deepseek.com/v1
+api_key: ${env.DEEPSEEK_API_KEY:=}
+```

scripts/generate_target_models_docs.py

@@ -69,6 +69,7 @@
 # These inference providers exist in the registry but do not have named
 # integration-test setups yet, so they are intentionally excluded from this doc.
 INTENTIONALLY_UNMAPPED_REGISTRY_PROVIDERS = {
+    "deepseek",
     "mistral",
     "meta",
     "nvidia",

src/ogx/providers/registry/inference.py

@@ -71,6 +71,16 @@ def available_providers() -> list[ProviderSpec]:
             provider_data_validator="ogx.providers.remote.inference.mistral.config.MistralProviderDataValidator",
             description="Mistral AI inference provider for accessing Mistral models via the Mistral API.",
         ),
+        RemoteProviderSpec(
+            api=Api.inference,
+            adapter_type="deepseek",
+            provider_type="remote::deepseek",
+            pip_packages=[],
+            module="ogx.providers.remote.inference.deepseek",
+            config_class="ogx.providers.remote.inference.deepseek.DeepSeekImplConfig",
+            provider_data_validator="ogx.providers.remote.inference.deepseek.config.DeepSeekProviderDataValidator",
+            description="DeepSeek inference provider for accessing DeepSeek models via the DeepSeek API.",
+        ),
         RemoteProviderSpec(
             api=Api.inference,
             adapter_type="ollama",

src/ogx/providers/remote/inference/deepseek/__init__.py

@@ -0,0 +1,19 @@
+# Copyright (c) The OGX Contributors.
+# All rights reserved.
+#
+# This source code is licensed under the terms described in the LICENSE file in
+# the root directory of this source tree.
+
+from .config import DeepSeekImplConfig
+
+
+async def get_adapter_impl(config: DeepSeekImplConfig, _deps):
+    from .deepseek import DeepSeekInferenceAdapter
+
+    assert isinstance(config, DeepSeekImplConfig), f"Unexpected config type: {type(config)}"
+
+    impl = DeepSeekInferenceAdapter(config=config)
+
+    await impl.initialize()
+
+    return impl

src/ogx/providers/remote/inference/deepseek/config.py

@@ -0,0 +1,41 @@
+# Copyright (c) The OGX Contributors.
+# All rights reserved.
+#
+# This source code is licensed under the terms described in the LICENSE file in
+# the root directory of this source tree.
+
+import os
+from typing import Any
+
+from pydantic import BaseModel, Field, HttpUrl, SecretStr
+
+from ogx.providers.utils.inference.model_registry import RemoteInferenceProviderConfig
+from ogx_api import json_schema_type
+
+DEFAULT_BASE_URL = "https://api.deepseek.com/v1"
+
+
+class DeepSeekProviderDataValidator(BaseModel):
+    """Validates provider-specific request data for DeepSeek inference."""
+
+    deepseek_api_key: SecretStr | None = Field(
+        default=None,
+        description="API key for DeepSeek models",
+    )
+
+
+@json_schema_type
+class DeepSeekImplConfig(RemoteInferenceProviderConfig):
+    """Configuration for the DeepSeek inference provider."""
+
+    base_url: HttpUrl | None = Field(
+        default=HttpUrl(os.environ.get("DEEPSEEK_BASE_URL", DEFAULT_BASE_URL)),
+        description="Base URL for the DeepSeek API",
+    )
+
+    @classmethod
+    def sample_run_config(cls, api_key: str = "${env.DEEPSEEK_API_KEY:=}", **kwargs) -> dict[str, Any]:
+        return {
+            "base_url": DEFAULT_BASE_URL,
+            "api_key": api_key,
+        }

src/ogx/providers/remote/inference/deepseek/deepseek.py

@@ -0,0 +1,66 @@
+# Copyright (c) The OGX Contributors.
+# All rights reserved.
+#
+# This source code is licensed under the terms described in the LICENSE file in
+# the root directory of this source tree.
+
+from collections.abc import AsyncIterator
+
+from ogx.providers.utils.inference.openai_mixin import OpenAIMixin
+from ogx_api import (
+    OpenAIChatCompletion,
+    OpenAIChatCompletionChunk,
+    OpenAIChatCompletionRequestWithExtraBody,
+    OpenAICompletion,
+    OpenAICompletionRequestWithExtraBody,
+    OpenAIEmbeddingsRequestWithExtraBody,
+    OpenAIEmbeddingsResponse,
+)
+
+from .config import DeepSeekImplConfig
+
+
+class DeepSeekInferenceAdapter(OpenAIMixin):
+    """Inference adapter for the DeepSeek platform.
+
+    DeepSeek exposes an OpenAI-compatible chat completions API, so the shared
+    `OpenAIMixin` handles requests once pointed at DeepSeek's base URL. See
+    https://api-docs.deepseek.com/.
+    """
+
+    config: DeepSeekImplConfig
+
+    provider_data_api_key_field: str = "deepseek_api_key"
+
+    def get_base_url(self) -> str:
+        return str(self.config.base_url)
+
+    async def openai_chat_completion(
+        self,
+        params: OpenAIChatCompletionRequestWithExtraBody,
+    ) -> OpenAIChatCompletion | AsyncIterator[OpenAIChatCompletionChunk]:
+        if params.response_format is not None and params.response_format.type == "json_schema":
+            raise ValueError(
+                "DeepSeek does not support response_format type 'json_schema'. Use 'json_object' or 'text' instead."
+            )
+        return await super().openai_chat_completion(params)
+
+    async def openai_embeddings(
+        self,
+        params: OpenAIEmbeddingsRequestWithExtraBody,
+    ) -> OpenAIEmbeddingsResponse:
+        raise NotImplementedError("DeepSeek does not expose an embeddings endpoint.")
+
+    async def openai_completion(
+        self,
+        params: OpenAICompletionRequestWithExtraBody,
+    ) -> OpenAICompletion | AsyncIterator[OpenAICompletion]:
+        """DeepSeek does not support the legacy /v1/completions endpoint.
+
+        DeepSeek's completion API exists only as a beta FIM feature behind a
+        separate base URL (https://api.deepseek.com/beta), so it is not
+        reachable through this adapter's standard API surface.
+        """
+        raise NotImplementedError(
+            "DeepSeek does not support /v1/completions endpoint. Only /v1/chat/completions is supported."
+        )

tests/integration/inference/test_openai_completion.py

@@ -56,6 +56,7 @@ def skip_if_model_doesnt_support_openai_completion(client_with_models, model_id)
         #  https://go.microsoft.com/fwlink/?linkid=2197993.'}}"}
         "remote::llama-openai-compat",
         "remote::watsonx",  # WatsonX only has /v1/chat/completions, no /v1/completions
+        "remote::deepseek",  # DeepSeek does not support /v1/completions
     ):
         pytest.skip(f"Model {model_id} hosted by {provider.provider_type} doesn't support OpenAI completions.")
 
@@ -107,6 +108,7 @@ def skip_if_doesnt_support_n(client_with_models, model_id):
         "remote::cerebras",
         "remote::databricks",  # Bad request: parameter "n" must be equal to 1 for streaming mode
         "remote::watsonx",
+        "remote::deepseek",  # n > 1 is not supported
     ):
         pytest.skip(f"Model {model_id} hosted by {provider.provider_type} doesn't support n param.")
 
@@ -146,6 +148,14 @@ def skip_if_provider_doesnt_support_tool_calling(client_with_models, model_id):
         pytest.skip(f"Model {model_id} hosted by {provider.provider_type} doesn't support tool calling.")
 
 
+def skip_if_doesnt_support_json_schema(client_with_models, model_id):
+    provider = provider_from_model(client_with_models, model_id)
+    if provider.provider_type in (
+        "remote::deepseek",  # DeepSeek doesn't support response_format type 'json_schema'
+    ):
+        pytest.skip(f"Model {model_id} hosted by {provider.provider_type} doesn't support json_schema response_format.")
+
+
 @pytest.mark.parametrize(
     "test_case",
     [
@@ -783,8 +793,9 @@ def test_openai_chat_completion_with_tool_choice_none(openai_client, text_model_
         "inference:chat_completion:structured_output",
     ],
 )
-def test_openai_chat_completion_structured_output(openai_client, text_model_id, test_case):
-    # Note: Skip condition may need adjustment for OpenAI client
+def test_openai_chat_completion_structured_output(openai_client, client_with_models, text_model_id, test_case):
+    skip_if_doesnt_support_json_schema(client_with_models, text_model_id)
+
     class AnswerFormat(BaseModel):
         first_name: str
         last_name: str

tests/unit/providers/inference/test_deepseek_config.py

@@ -0,0 +1,68 @@
+# Copyright (c) The OGX Contributors.
+# All rights reserved.
+#
+# This source code is licensed under the terms described in the LICENSE file in
+# the root directory of this source tree.
+
+import os
+from unittest.mock import patch
+
+import pytest
+
+from ogx.core.stack import replace_env_vars
+from ogx.providers.remote.inference.deepseek.config import DeepSeekImplConfig
+from ogx.providers.remote.inference.deepseek.deepseek import DeepSeekInferenceAdapter
+from ogx_api import OpenAICompletionRequestWithExtraBody
+
+
+class TestDeepSeekConfig:
+    """Tests for the DeepSeek inference provider config and adapter wiring."""
+
+    def test_default_base_url(self):
+        config = DeepSeekImplConfig(api_key="test-key")
+        adapter = DeepSeekInferenceAdapter(config=config)
+        adapter.provider_data_api_key_field = None
+
+        assert adapter.get_base_url() == "https://api.deepseek.com/v1"
+
+    def test_custom_base_url_from_config(self):
+        custom_url = "https://custom.deepseek.com/v1"
+        config = DeepSeekImplConfig(api_key="test-key", base_url=custom_url)
+        adapter = DeepSeekInferenceAdapter(config=config)
+        adapter.provider_data_api_key_field = None
+
+        assert adapter.get_base_url() == custom_url
+
+    @patch.dict(os.environ, {"DEEPSEEK_BASE_URL": "https://env.deepseek.com/v1"})
+    def test_base_url_from_environment_variable(self):
+        config_data = DeepSeekImplConfig.sample_run_config(api_key="test-key")
+        processed_config = replace_env_vars(config_data)
+        config = DeepSeekImplConfig.model_validate(processed_config)
+
+        assert str(config.base_url) == "https://api.deepseek.com/v1"
+
+    def test_sample_run_config_uses_env_placeholder(self):
+        cfg = DeepSeekImplConfig.sample_run_config()
+        assert cfg["base_url"] == "https://api.deepseek.com/v1"
+        assert cfg["api_key"] == "${env.DEEPSEEK_API_KEY:=}"
+
+    def test_provider_data_api_key_field(self):
+        config = DeepSeekImplConfig(api_key="test-key")
+        adapter = DeepSeekInferenceAdapter(config=config)
+        assert adapter.provider_data_api_key_field == "deepseek_api_key"
+
+    async def test_embeddings_not_supported(self):
+        config = DeepSeekImplConfig(api_key="test-key")
+        adapter = DeepSeekInferenceAdapter(config=config)
+        with pytest.raises(NotImplementedError, match="does not expose an embeddings endpoint"):
+            await adapter.openai_embeddings(None)  # type: ignore[arg-type]
+
+    async def test_legacy_completions_endpoint_not_supported(self):
+        """DeepSeek does not support the legacy /v1/completions endpoint."""
+        config = DeepSeekImplConfig(api_key="test-key")
+        adapter = DeepSeekInferenceAdapter(config=config)
+
+        params = OpenAICompletionRequestWithExtraBody(model="deepseek-chat", prompt="Hello")
+
+        with pytest.raises(NotImplementedError, match="does not support /v1/completions endpoint"):
+            await adapter.openai_completion(params)