chore: initial public snapshot for github upload

llm-gateway-competitors/litellm-wheel-src/litellm/llms/deepseek/chat/transformation.py

@@ -0,0 +1,125 @@
+"""
+Translates from OpenAI's `/v1/chat/completions` to DeepSeek's `/v1/chat/completions`
+"""
+
+from typing import Any, Coroutine, List, Literal, Optional, Tuple, Union, overload
+
+from litellm.litellm_core_utils.prompt_templates.common_utils import (
+    handle_messages_with_content_list_to_str_conversion,
+)
+from litellm.secret_managers.main import get_secret_str
+from litellm.types.llms.openai import AllMessageValues
+
+from ...openai.chat.gpt_transformation import OpenAIGPTConfig
+
+
+class DeepSeekChatConfig(OpenAIGPTConfig):
+    def get_supported_openai_params(self, model: str) -> list:
+        """
+        DeepSeek reasoner models support thinking parameter.
+        """
+        params = super().get_supported_openai_params(model)
+        params.extend(["thinking", "reasoning_effort"])
+        return params
+
+    def map_openai_params(
+        self,
+        non_default_params: dict,
+        optional_params: dict,
+        model: str,
+        drop_params: bool,
+    ) -> dict:
+        """
+        Map OpenAI params to DeepSeek params.
+
+        Handles `thinking` and `reasoning_effort` parameters for DeepSeek reasoner models.
+        DeepSeek only supports `{"type": "enabled"}` - no budget_tokens like Anthropic.
+
+        Reference: https://api-docs.deepseek.com/guides/thinking_mode
+        """
+        # Let parent handle standard params first
+        optional_params = super().map_openai_params(
+            non_default_params, optional_params, model, drop_params
+        )
+
+        # Pop thinking/reasoning_effort from optional_params first (parent may have added them)
+        # Then re-add only if valid for DeepSeek
+        thinking_value = optional_params.pop("thinking", None)
+        reasoning_effort = optional_params.pop("reasoning_effort", None)
+
+        # Handle thinking parameter - only accept {"type": "enabled"}
+        if thinking_value is not None:
+            if (
+                isinstance(thinking_value, dict)
+                and thinking_value.get("type") == "enabled"
+            ):
+                # DeepSeek only accepts {"type": "enabled"}, ignore budget_tokens
+                optional_params["thinking"] = {"type": "enabled"}
+
+        # Handle reasoning_effort - map to thinking enabled
+        elif reasoning_effort is not None and reasoning_effort != "none":
+            optional_params["thinking"] = {"type": "enabled"}
+
+        return optional_params
+
+    @overload
+    def _transform_messages(
+        self, messages: List[AllMessageValues], model: str, is_async: Literal[True]
+    ) -> Coroutine[Any, Any, List[AllMessageValues]]:
+        ...
+
+    @overload
+    def _transform_messages(
+        self,
+        messages: List[AllMessageValues],
+        model: str,
+        is_async: Literal[False] = False,
+    ) -> List[AllMessageValues]:
+        ...
+
+    def _transform_messages(
+        self, messages: List[AllMessageValues], model: str, is_async: bool = False
+    ) -> Union[List[AllMessageValues], Coroutine[Any, Any, List[AllMessageValues]]]:
+        """
+        DeepSeek does not support content in list format.
+        """
+        messages = handle_messages_with_content_list_to_str_conversion(messages)
+        if is_async:
+            return super()._transform_messages(
+                messages=messages, model=model, is_async=True
+            )
+        else:
+            return super()._transform_messages(
+                messages=messages, model=model, is_async=False
+            )
+
+    def _get_openai_compatible_provider_info(
+        self, api_base: Optional[str], api_key: Optional[str]
+    ) -> Tuple[Optional[str], Optional[str]]:
+        api_base = (
+            api_base
+            or get_secret_str("DEEPSEEK_API_BASE")
+            or "https://api.deepseek.com/beta"
+        )  # type: ignore
+        dynamic_api_key = api_key or get_secret_str("DEEPSEEK_API_KEY")
+        return api_base, dynamic_api_key
+
+    def get_complete_url(
+        self,
+        api_base: Optional[str],
+        api_key: Optional[str],
+        model: str,
+        optional_params: dict,
+        litellm_params: dict,
+        stream: Optional[bool] = None,
+    ) -> str:
+        """
+        If api_base is not provided, use the default DeepSeek /chat/completions endpoint.
+        """
+        if not api_base:
+            api_base = "https://api.deepseek.com/beta"
+
+        if not api_base.endswith("/chat/completions"):
+            api_base = f"{api_base}/chat/completions"
+
+        return api_base

llm-gateway-competitors/litellm-wheel-src/litellm/llms/deepseek/cost_calculator.py

@@ -0,0 +1,21 @@
+"""
+Cost calculator for DeepSeek Chat models. 
+
+Handles prompt caching scenario.
+"""
+
+from typing import Tuple
+
+from litellm.litellm_core_utils.llm_cost_calc.utils import generic_cost_per_token
+from litellm.types.utils import Usage
+
+
+def cost_per_token(model: str, usage: Usage) -> Tuple[float, float]:
+    """
+    Calculates the cost per token for a given model, prompt tokens, and completion tokens.
+
+    Follows the same logic as Anthropic's cost per token calculation.
+    """
+    return generic_cost_per_token(
+        model=model, usage=usage, custom_llm_provider="deepseek"
+    )