my-claude-code 7.13.1__py3-none-any.whl

my_claude_code/providers/deepseek/compat.py

@@ -0,0 +1,376 @@
+"""DeepSeek Anthropic-to-OpenAI chat request policy."""
+
+from collections.abc import Mapping
+from typing import Any
+
+from loguru import logger
+
+from my_claude_code.application.errors import InvalidRequestError
+from my_claude_code.config.settings import configured_default_max_output_tokens
+from my_claude_code.core.anthropic import (
+    ReasoningReplayMode,
+    dump_messages_request,
+    serialize_tool_result_content,
+)
+from my_claude_code.core.anthropic.models import MessagesRequest
+from my_claude_code.core.reasoning import (
+    ReasoningControl,
+    ReasoningPolicy,
+)
+from my_claude_code.providers.openai_chat import (
+    OpenAIChatRequestPolicy,
+    build_openai_chat_request_body,
+)
+
+DEEPSEEK_REQUEST_POLICY = OpenAIChatRequestPolicy(
+    provider_name="DEEPSEEK",
+    reasoning_replay=ReasoningReplayMode.REASONING_CONTENT,
+    include_extra_body=True,
+)
+
+# Server-tool blocks DeepSeek's native surface cannot represent at all. Images
+# and documents are deliberately *not* here any more: since 6.49.0 the router
+# replaces a visual block with a placeholder for any model published as not
+# accepting images -- which DeepSeek's chat models are -- so by the time a body
+# is built there is nothing to strip, and the general rule covers every other
+# provider too. A DeepSeek model that does publish image support now gets the
+# picture through the ordinary hoist rather than a provider-specific refusal.
+_UNSUPPORTED_MESSAGE_BLOCK_TYPES = frozenset(
+    {
+        "server_tool_use",
+        "web_search_tool_result",
+        "web_fetch_tool_result",
+    }
+)
+
+
+def build_deepseek_request_body(
+    request_data: MessagesRequest,
+    *,
+    reasoning: ReasoningPolicy,
+    provider_id: str = "",
+) -> dict:
+    """Build a DeepSeek Chat Completions body from an Anthropic request."""
+    logger.debug(
+        "DEEPSEEK_REQUEST: chat build model={} msgs={}",
+        request_data.model,
+        len(request_data.messages),
+    )
+
+    data = dump_messages_request(request_data)
+    _validate_deepseek_request_dict(data)
+
+    has_tool_history = _has_tool_history(data)
+    has_replayable_tool_thinking = _all_tool_calls_have_replayable_thinking(data)
+    unsafe_tool_followup = has_tool_history and not has_replayable_tool_thinking
+    effective_reasoning = reasoning
+    if reasoning.control is not ReasoningControl.OFF:
+        if unsafe_tool_followup:
+            logger.debug(
+                "DEEPSEEK_REQUEST: disabling thinking for tool follow-up without "
+                "replayable thinking model={} msgs={} tools={}",
+                data.get("model"),
+                len(data.get("messages", [])),
+                len(data.get("tools", [])),
+            )
+            _remove_deepseek_thinking_hints(data)
+            effective_reasoning = ReasoningPolicy.off()
+        elif has_tool_history:
+            logger.debug(
+                "DEEPSEEK_REQUEST: keeping thinking for tool follow-up with "
+                "replayable thinking model={} msgs={} tools={}",
+                data.get("model"),
+                len(data.get("messages", [])),
+                len(data.get("tools", [])),
+            )
+        elif data.get("tools") or data.get("tool_choice"):
+            logger.debug(
+                "DEEPSEEK_REQUEST: keeping thinking for initial tool request "
+                "model={} msgs={} tools={}",
+                data.get("model"),
+                len(data.get("messages", [])),
+                len(data.get("tools", [])),
+            )
+
+    if "messages" in data:
+        data["messages"] = _normalize_tool_result_content(
+            sanitize_deepseek_messages_for_openai(data["messages"])
+        )
+
+    sanitized_request = MessagesRequest.model_validate(data)
+    body = build_openai_chat_request_body(
+        sanitized_request,
+        reasoning=effective_reasoning,
+        policy=DEEPSEEK_REQUEST_POLICY,
+        postprocessors=(_apply_deepseek_chat_extras,),
+        provider_id=provider_id,
+    )
+    if body.get("max_tokens") is None:
+        configured = configured_default_max_output_tokens()
+        if configured is None:
+            body.pop("max_tokens", None)
+        else:
+            body["max_tokens"] = configured
+
+    logger.debug(
+        "DEEPSEEK_REQUEST: build done model={} msgs={} tools={}",
+        body.get("model"),
+        len(body.get("messages", [])),
+        len(body.get("tools", [])),
+    )
+    return body
+
+
+def sanitize_deepseek_messages_for_openai(messages: Any) -> Any:
+    """Keep only DeepSeek-required reasoning history on assistant tool calls."""
+    if not isinstance(messages, list):
+        return messages
+
+    sanitized: list[Any] = []
+    for message in messages:
+        if not isinstance(message, dict):
+            sanitized.append(message)
+            continue
+        if message.get("role") != "assistant":
+            sanitized.append(message)
+            continue
+        replay_tool_reasoning = _assistant_has_tool_use(message)
+        new_msg = dict(message)
+        if not replay_tool_reasoning:
+            new_msg.pop("reasoning_content", None)
+        content = message.get("content")
+        if not isinstance(content, list):
+            sanitized.append(new_msg)
+            continue
+
+        filtered = [
+            block
+            for block in content
+            if not (
+                isinstance(block, dict)
+                and (
+                    block.get("type") == "redacted_thinking"
+                    or (block.get("type") == "thinking" and not replay_tool_reasoning)
+                )
+            )
+        ]
+        new_msg["content"] = filtered or ""
+        sanitized.append(new_msg)
+    return sanitized
+
+
+def _is_server_listed_tool(tool: Mapping[str, Any]) -> bool:
+    name = (tool.get("name") or "").strip()
+    if name in ("web_search", "web_fetch"):
+        return True
+    typ = tool.get("type")
+    if isinstance(typ, str):
+        return typ.startswith("web_search") or typ.startswith("web_fetch")
+    return False
+
+
+def _walk_block_list_for_unsupported(blocks: Any, *, where: str) -> None:
+    if not isinstance(blocks, list):
+        return
+    for block in blocks:
+        if not isinstance(block, dict):
+            continue
+        btype = block.get("type")
+        if btype in _UNSUPPORTED_MESSAGE_BLOCK_TYPES:
+            raise InvalidRequestError(
+                f"DeepSeek native does not support {btype!r} blocks ({where})."
+            )
+        if btype == "tool_result" and "content" in block:
+            _walk_block_list_for_unsupported(
+                block["content"], where=f"{where} (tool_result content)"
+            )
+
+
+def _validate_deepseek_request_dict(data: dict[str, Any]) -> None:
+    mcp = data.get("mcp_servers")
+    if mcp:
+        raise InvalidRequestError("DeepSeek does not support mcp_servers on requests.")
+
+    for tool in data.get("tools") or ():
+        if not isinstance(tool, dict):
+            continue
+        if _is_server_listed_tool(tool):
+            raise InvalidRequestError(
+                "DeepSeek does not support listed Anthropic server tools "
+                "(web_search / web_fetch). Remove them or use a different provider."
+            )
+
+    for i, message in enumerate(data.get("messages") or ()):
+        if not isinstance(message, dict):
+            continue
+        content = message.get("content")
+        if isinstance(content, list):
+            _walk_block_list_for_unsupported(content, where=f"messages[{i}].content")
+
+    system = data.get("system")
+    if isinstance(system, list):
+        _walk_block_list_for_unsupported(system, where="system")
+
+
+def _has_tool_history_blocks(message: Mapping[str, Any]) -> bool:
+    role = message.get("role")
+    content = message.get("content")
+    if not isinstance(content, list):
+        return False
+
+    for block in content:
+        if not isinstance(block, dict):
+            continue
+        btype = block.get("type")
+        if role == "assistant" and btype == "tool_use":
+            return True
+        if role == "user" and btype == "tool_result":
+            return True
+    return False
+
+
+def _has_replayable_thinking_before_tool_use(message: Mapping[str, Any]) -> bool:
+    if message.get("role") != "assistant":
+        return False
+    content = message.get("content")
+    if not isinstance(content, list):
+        return False
+
+    has_thinking = isinstance(message.get("reasoning_content"), str)
+    for block in content:
+        if not isinstance(block, dict):
+            continue
+        btype = block.get("type")
+        if btype == "thinking" and isinstance(block.get("thinking"), str):
+            has_thinking = True
+            continue
+        if btype == "tool_use":
+            return has_thinking
+    return False
+
+
+def _assistant_has_tool_use(message: Mapping[str, Any]) -> bool:
+    if message.get("role") != "assistant":
+        return False
+    content = message.get("content")
+    return isinstance(content, list) and any(
+        isinstance(block, dict) and block.get("type") == "tool_use" for block in content
+    )
+
+
+def _has_tool_history(data: dict[str, Any]) -> bool:
+    for message in data.get("messages") or ():
+        if isinstance(message, Mapping) and _has_tool_history_blocks(message):
+            return True
+    return False
+
+
+def _all_tool_calls_have_replayable_thinking(data: dict[str, Any]) -> bool:
+    found_tool_call = False
+    for message in data.get("messages") or ():
+        if not isinstance(message, Mapping) or not _assistant_has_tool_use(message):
+            continue
+        found_tool_call = True
+        if not _has_replayable_thinking_before_tool_use(message):
+            return False
+    return found_tool_call
+
+
+def _remove_deepseek_thinking_hints(data: dict[str, Any]) -> None:
+    output_config = data.get("output_config")
+    if isinstance(output_config, dict) and "effort" in output_config:
+        cleaned_output_config = dict(output_config)
+        cleaned_output_config.pop("effort", None)
+        if cleaned_output_config:
+            data["output_config"] = cleaned_output_config
+        else:
+            data.pop("output_config", None)
+
+    context_management = data.get("context_management")
+    if not isinstance(context_management, dict):
+        return
+    edits = context_management.get("edits")
+    if not isinstance(edits, list):
+        return
+    filtered_edits = [
+        edit
+        for edit in edits
+        if not (
+            isinstance(edit, dict)
+            and isinstance(edit.get("type"), str)
+            and edit["type"].startswith("clear_thinking_")
+        )
+    ]
+    if len(filtered_edits) == len(edits):
+        return
+    cleaned_context_management = dict(context_management)
+    if filtered_edits:
+        cleaned_context_management["edits"] = filtered_edits
+        data["context_management"] = cleaned_context_management
+    else:
+        cleaned_context_management.pop("edits", None)
+        if cleaned_context_management:
+            data["context_management"] = cleaned_context_management
+        else:
+            data.pop("context_management", None)
+
+
+def _normalize_tool_result_content(messages: Any) -> Any:
+    if not isinstance(messages, list):
+        return messages
+
+    normalized: list[Any] = []
+    for message in messages:
+        if not isinstance(message, dict):
+            normalized.append(message)
+            continue
+
+        content = message.get("content")
+        if not isinstance(content, list):
+            normalized.append(message)
+            continue
+
+        new_content: list[Any] = []
+        for block in content:
+            if not isinstance(block, dict):
+                new_content.append(block)
+                continue
+
+            if block.get("type") == "tool_result":
+                normalized_block = dict(block)
+                normalized_block["content"] = serialize_tool_result_content(
+                    block.get("content")
+                )
+                new_content.append(normalized_block)
+            else:
+                new_content.append(block)
+
+        new_msg = dict(message)
+        new_msg["content"] = new_content
+        normalized.append(new_msg)
+
+    return normalized
+
+
+def _apply_deepseek_chat_extras(
+    body: dict[str, Any], _request_data: MessagesRequest, policy: ReasoningPolicy
+) -> None:
+    extra_body = body.setdefault("extra_body", {})
+    if not isinstance(extra_body, dict):
+        return
+    if policy.control is ReasoningControl.OFF:
+        extra_body["thinking"] = {"type": "disabled"}
+        return
+    # 2026-08-29: send the effort the caller actually asked for. This used to
+    # collapse the whole ladder onto two rungs -- "max" for XHIGH/MAX and "high"
+    # for everything else -- so a request for MINIMAL bought HIGH's latency and
+    # tokens, and MEDIUM and HIGH were indistinguishable. DeepSeek names its own
+    # enum when it rejects an invalid one: "reasoning_effort: unknown variant
+    # `bogus_value`, expected one of `none`, `minimal`, `low`, `medium`, `high`,
+    # `xhigh`, `max`". That is FCC's :class:`ReasoningEffort` ladder exactly,
+    # value for value, so the translation is the identity and no per-model
+    # branching is needed to pick it.
+    if policy.effort is not None:
+        body["reasoning_effort"] = policy.effort.value
+    elif policy.requests_reasoning:
+        extra_body["thinking"] = {"type": "enabled"}

my_claude_code/providers/deepseek/tool_choice.py

@@ -0,0 +1,72 @@
+"""DeepSeek forced tool_choice rejection recovery.
+
+DeepSeek's documented Chat Completions API accepts a forced named
+``tool_choice`` (``{"type": "function", "function": {"name": ...}}``), but
+some DeepSeek reasoning models reject it at request time with an HTTP 400
+even though the shape is spec-compliant. This module detects that specific
+rejection reactively (from the upstream error, never from the model name --
+DeepSeek's model ids have already shifted once and are not a stable signal)
+and produces a retry body that keeps the "must call some tool" half of the
+caller's intent by downgrading to ``"required"``.
+"""
+
+from copy import deepcopy
+from typing import Any
+
+from my_claude_code.providers.recovery import is_bad_request, upstream_complaint
+
+_REJECTION_HINTS = (
+    "tool_choice",
+    "tool choice",
+)
+_UNSUPPORTED_WORDS = (
+    "not support",
+    "unsupported",
+    "does not support",
+    "invalid",
+    "not allowed",
+    "not permitted",
+)
+
+
+def is_deepseek_tool_choice_rejection(error: Exception) -> bool:
+    """Return whether an upstream error rejects a forced ``tool_choice``.
+
+    Matches narrowly: the error must be a request-validation rejection AND the
+    provider's own words must mention ``tool_choice`` (or "tool choice")
+    together with an unsupported/rejection word (e.g. "does not support",
+    "invalid", "not allowed"). Requiring both keeps this from firing on
+    unrelated 400s such as context-length-exceeded or bad-schema errors, which
+    never mention tool_choice at all.
+
+    Echo-safe since 6.33.0: the words come from the fleet-wide matcher, which
+    prunes the keys under which a validation error echoes the submitted request
+    back. Reading that echo made every forced-tool request its own evidence --
+    the body it sent contains ``tool_choice`` by definition, and one unrelated
+    "invalid" anywhere in the same 400 was enough to complete the pair.
+    """
+    if not is_bad_request(error):
+        return False
+    complaint = upstream_complaint(error)
+    mentions_tool_choice = any(hint in complaint for hint in _REJECTION_HINTS)
+    mentions_rejection = any(word in complaint for word in _UNSUPPORTED_WORDS)
+    return mentions_tool_choice and mentions_rejection
+
+
+def clone_body_with_required_tool_choice(body: dict[str, Any]) -> dict[str, Any] | None:
+    """Return a body clone with a forced named ``tool_choice`` downgraded.
+
+    Downgrades OpenAI-shaped ``{"type": "function", "function": {"name": ...}}``
+    to the string ``"required"`` -- the caller demanded a tool call, and
+    ``"required"`` preserves that half even when the *which tool* half
+    cannot be honoured. Returns ``None`` if there is nothing to downgrade
+    (i.e. ``tool_choice`` was not a forced named choice), so the caller can
+    tell "no retry available" apart from "retry with an unchanged body".
+    """
+    tool_choice = body.get("tool_choice")
+    if not isinstance(tool_choice, dict) or tool_choice.get("type") != "function":
+        return None
+
+    cloned = deepcopy(body)
+    cloned["tool_choice"] = "required"
+    return cloned