feat: add DeepSeek extreme reasoning tier

agent_platform/runtime/provider.py

@@ -6,6 +6,7 @@ from typing import Any
 import httpx
 
 from agent_platform.config import Settings
+from agent_platform.models import Provider
 
 TRANSIENT_COMPLETE_STATUS_CODES = frozenset({408, 425, 429, 500, 502, 503, 504, 524})
 COMPLETE_MAX_ATTEMPTS = 2
@@ -132,11 +133,37 @@ class ModelProvider:
 
     @property
     def headers(self) -> dict[str, str]:
+        return self._headers("k1412")
+
+    def _headers(self, provider: Provider) -> dict[str, str]:
+        key = self.settings.deepseek_api_key if provider == "deepseek" else self.settings.model_api_key
         return {
-            "Authorization": f"Bearer {self.settings.model_api_key}",
+            "Authorization": f"Bearer {key}",
             "Content-Type": "application/json",
         }
 
+    def _base_url(self, provider: Provider) -> str:
+        return self.settings.deepseek_api_base_url if provider == "deepseek" else self.settings.model_api_base_url
+
+    @staticmethod
+    def _provider_payload(
+        payload: dict[str, Any],
+        *,
+        provider: Provider,
+        thinking_enabled: bool,
+        reasoning_effort: str | None,
+        max_output_tokens: int,
+    ) -> dict[str, Any]:
+        value = dict(payload)
+        value.pop("thinking", None)
+        value.pop("reasoning_effort", None)
+        value["max_tokens"] = max_output_tokens
+        if provider == "deepseek" and thinking_enabled:
+            value["thinking"] = {"type": "enabled"}
+            if reasoning_effort:
+                value["reasoning_effort"] = reasoning_effort
+        return value
+
     async def close(self) -> None:
         if self._owns_client:
             await self.client.aclose()
@@ -148,13 +175,22 @@ class ModelProvider:
         messages: list[dict[str, Any]],
         tools: list[dict[str, Any]] | None = None,
         temperature: float | None = None,
+        provider: Provider = "k1412",
+        thinking_enabled: bool = False,
+        reasoning_effort: str | None = None,
+        max_output_tokens: int = COMPLETE_MAX_TOKENS,
     ) -> dict[str, Any]:
-        payload: dict[str, Any] = {
-            "model": model,
-            "messages": messages,
-            "stream": True,
-            "max_tokens": COMPLETE_MAX_TOKENS,
-        }
+        payload = self._provider_payload(
+            {
+                "model": model,
+                "messages": messages,
+                "stream": True,
+            },
+            provider=provider,
+            thinking_enabled=thinking_enabled,
+            reasoning_effort=reasoning_effort,
+            max_output_tokens=max_output_tokens,
+        )
         if tools:
             payload["tools"] = tools
             payload["tool_choice"] = "auto"
@@ -165,8 +201,8 @@ class ModelProvider:
             try:
                 async with self.client.stream(
                     "POST",
-                    completions_url(self.settings.model_api_base_url),
-                    headers=self.headers,
+                    completions_url(self._base_url(provider)),
+                    headers=self._headers(provider),
                     json=payload,
                 ) as response:
                     if response.status_code in TRANSIENT_COMPLETE_STATUS_CODES and attempt < COMPLETE_MAX_ATTEMPTS:
@@ -184,11 +220,26 @@ class ModelProvider:
 
         raise RuntimeError("Model provider retry loop exited unexpectedly")
 
-    async def forward(self, payload: dict[str, Any]) -> httpx.Response:
+    async def forward(
+        self,
+        payload: dict[str, Any],
+        *,
+        provider: Provider = "k1412",
+        thinking_enabled: bool = False,
+        reasoning_effort: str | None = None,
+        max_output_tokens: int = COMPLETE_MAX_TOKENS,
+    ) -> httpx.Response:
+        payload = self._provider_payload(
+            payload,
+            provider=provider,
+            thinking_enabled=thinking_enabled,
+            reasoning_effort=reasoning_effort,
+            max_output_tokens=max_output_tokens,
+        )
         request = self.client.build_request(
             "POST",
-            completions_url(self.settings.model_api_base_url),
-            headers=self.headers,
+            completions_url(self._base_url(provider)),
+            headers=self._headers(provider),
             json=payload,
         )
         response = await self.client.send(request, stream=bool(payload.get("stream")))