diff --git a/litellm/llms/anthropic/chat/transformation.py b/litellm/llms/anthropic/chat/transformation.py index 1f90d375bc2..bbea06e2cfc 100644 --- a/litellm/llms/anthropic/chat/transformation.py +++ b/litellm/llms/anthropic/chat/transformation.py @@ -1685,6 +1685,19 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig): """ return False + def should_strip_claude_code_identity(self) -> bool: + """ + Whether to drop Claude Code's self-identification from the system prompt. + + Distinct from ``should_strip_billing_metadata``: that drops the billing header on + every provider whose request shape rejects it, including Bedrock/Vertex/Azure, which + still serve *Claude* models. This only trips on providers whose + Anthropic-compatible endpoint serves a *different* model, where "You are Claude + Code" is a false self-description. The first-party config and the Claude-serving + providers keep it, so this stays False here. + """ + return False + def translate_system_message(self, messages: list[AllMessageValues]) -> list[AnthropicSystemMessageContent]: """ Translate system message to anthropic format. diff --git a/litellm/llms/anthropic/common_utils.py b/litellm/llms/anthropic/common_utils.py index 98e2f6d5bde..8bd9c56d92e 100644 --- a/litellm/llms/anthropic/common_utils.py +++ b/litellm/llms/anthropic/common_utils.py @@ -77,6 +77,9 @@ _CLAUDE_CODE_OBJECT_LIST_ADAPTER: Final = TypeAdapter(list[object]) _CLAUDE_CODE_USER_AGENT_PREFIXES: Final = ("claude-cli/", "claude-code/") +_CLAUDE_CODE_IDENTITY: Final = "You are Claude Code, Anthropic's official CLI for Claude." + + def supports_anthropic_cache_control(model: str, custom_llm_provider: str | None) -> bool: from litellm.litellm_core_utils.get_llm_provider_logic import get_llm_provider from litellm.utils import supports_prompt_caching @@ -98,6 +101,25 @@ def is_claude_code_user_agent(user_agent: str) -> bool: return user_agent.startswith(_CLAUDE_CODE_USER_AGENT_PREFIXES) +def strip_claude_code_identity(text: str) -> str | None: + """Remove Claude Code's self-identification sentence from a single system text block. + + Claude Code prefixes its system prompt with ``You are Claude Code, Anthropic's + official CLI for Claude.``. When that prompt is forwarded to a non-Claude model + (e.g. a DeepSeek-compatible or OpenAI-like Anthropic-compatible endpoint), the + sentence is a false self-description and should be dropped before sending + upstream. Returns ``None`` when the text was nothing but the identity sentence + (so callers can drop the whole block), otherwise the text with the sentence and + its framing whitespace removed. + """ + stripped: Final = text.strip() + if stripped == _CLAUDE_CODE_IDENTITY: + return None + if stripped.startswith(_CLAUDE_CODE_IDENTITY): + return text.replace(_CLAUDE_CODE_IDENTITY, "", 1).lstrip("\n") + return text + + def _validated_claude_code_mapping(value: object) -> dict[object, object] | None: try: return _CLAUDE_CODE_OBJECT_MAPPING_ADAPTER.validate_python(value) diff --git a/litellm/llms/anthropic/experimental_pass_through/messages/transformation.py b/litellm/llms/anthropic/experimental_pass_through/messages/transformation.py index 5fa686b7560..641f7410126 100644 --- a/litellm/llms/anthropic/experimental_pass_through/messages/transformation.py +++ b/litellm/llms/anthropic/experimental_pass_through/messages/transformation.py @@ -25,6 +25,7 @@ from ...common_utils import ( AnthropicModelInfo, optionally_handle_anthropic_oauth, strip_advisor_blocks_from_messages, + strip_claude_code_identity, strip_encrypted_reasoning_blocks_from_anthropic_messages, ) from .mid_conversation_system import ( @@ -122,6 +123,56 @@ class AnthropicMessagesConfig(BaseAnthropicMessagesConfig): """ return False + def should_strip_claude_code_identity(self) -> bool: + """ + Whether to drop Claude Code's self-identification from the system prompt. + + Distinct from ``should_strip_billing_metadata``: that drops the billing header on + every provider whose request shape rejects it, including Bedrock/Vertex/Azure, which + still serve *Claude* models. This only trips on providers whose + Anthropic-compatible endpoint serves a *different* model (DeepSeek, MiniMax, + Tencent, OpenAI-like passthrough), where "You are Claude Code" is a false + self-description. The first-party config keeps it. + """ + return False + + @staticmethod + def _strip_claude_code_identity_from_system(system_param): + """ + Strip Claude Code's self-identification sentence from system parameter. + + Args: + system_param: Can be a string or a list of system message content blocks + + Returns: + System parameter with the identity sentence removed, or None if all content was removed + """ + if isinstance(system_param, str): + return strip_claude_code_identity(system_param) + elif isinstance(system_param, list): + filtered_list: Final = [] + for content_block in system_param: + if isinstance(content_block, dict): + text = content_block.get("text", "") + content_type = content_block.get("type", "") + if content_type != "text": + filtered_list.append(content_block) + continue + stripped_text: Final[str | None] = strip_claude_code_identity(text) + if stripped_text is None: + continue + # Only copy the block when the text changed. + if stripped_text == text: + filtered_list.append(content_block) + else: + filtered_list.append({**content_block, "text": stripped_text}) + else: + # Keep non-dict items as-is + filtered_list.append(content_block) + return filtered_list if len(filtered_list) > 0 else None + else: + return system_param + @staticmethod def _filter_billing_headers_from_system(system_param): """ @@ -529,6 +580,14 @@ class AnthropicMessagesConfig(BaseAnthropicMessagesConfig): else: anthropic_messages_optional_request_params.pop("system", None) + stripped_identity_system: Final = anthropic_messages_optional_request_params.get("system") + if self.should_strip_claude_code_identity() and stripped_identity_system is not None: + identity_filtered: Final = self._strip_claude_code_identity_from_system(stripped_identity_system) + if identity_filtered is not None and len(identity_filtered) > 0: + anthropic_messages_optional_request_params["system"] = identity_filtered + else: + anthropic_messages_optional_request_params.pop("system", None) + # Transform context_management from OpenAI format to Anthropic format if needed context_management_param: Final = anthropic_messages_optional_request_params.get("context_management") if context_management_param is not None: diff --git a/litellm/llms/deepseek/messages/transformation.py b/litellm/llms/deepseek/messages/transformation.py index 8dd720c464a..d7d44d1cba2 100644 --- a/litellm/llms/deepseek/messages/transformation.py +++ b/litellm/llms/deepseek/messages/transformation.py @@ -29,6 +29,9 @@ class DeepSeekAnthropicMessagesConfig(AnthropicMessagesConfig): def should_strip_billing_metadata(self) -> bool: return True + def should_strip_claude_code_identity(self) -> bool: + return True + @staticmethod def get_api_key(api_key: str | None = None) -> str | None: return api_key or get_secret_str("DEEPSEEK_API_KEY") or litellm.api_key diff --git a/litellm/llms/minimax/messages/transformation.py b/litellm/llms/minimax/messages/transformation.py index d4c24c65cfa..aaa5a46d73f 100644 --- a/litellm/llms/minimax/messages/transformation.py +++ b/litellm/llms/minimax/messages/transformation.py @@ -31,6 +31,9 @@ class MinimaxMessagesConfig(AnthropicMessagesConfig): def should_strip_billing_metadata(self) -> bool: return True + def should_strip_claude_code_identity(self) -> bool: + return True + @staticmethod def get_api_key(api_key: str | None = None) -> str | None: """ diff --git a/litellm/llms/openai_like/messages/transformation.py b/litellm/llms/openai_like/messages/transformation.py index bae190c88c0..28cd069e412 100644 --- a/litellm/llms/openai_like/messages/transformation.py +++ b/litellm/llms/openai_like/messages/transformation.py @@ -32,6 +32,9 @@ class OpenAILikeAnthropicMessagesConfig(AnthropicMessagesConfig): super().__init__() self._cache_control_ttl: Final = cache_control_ttl + def should_strip_claude_code_identity(self) -> bool: + return True + def validate_anthropic_messages_environment( self, headers: dict[str, str], diff --git a/litellm/llms/tencent/messages/transformation.py b/litellm/llms/tencent/messages/transformation.py index f1d9ee966ff..1e8d7243083 100644 --- a/litellm/llms/tencent/messages/transformation.py +++ b/litellm/llms/tencent/messages/transformation.py @@ -30,6 +30,9 @@ class TencentAnthropicMessagesConfig(AnthropicMessagesConfig): def should_strip_billing_metadata(self) -> bool: return True + def should_strip_claude_code_identity(self) -> bool: + return True + @staticmethod def get_api_key(api_key: str | None = None) -> str | None: return api_key or get_secret_str("TENCENT_API_KEY") or litellm.api_key diff --git a/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py b/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py index 633dd1d9460..8806c297db6 100644 --- a/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py +++ b/tests/test_litellm/llms/anthropic/chat/test_anthropic_chat_transformation.py @@ -5894,6 +5894,120 @@ def test_should_strip_billing_metadata_by_provider( assert config_cls().should_strip_billing_metadata() is expected_strip +@pytest.mark.parametrize( + "module_path, class_name, expected_strip", + [ + # First-party and Claude-serving providers keep the identity sentence: the + # model genuinely *is* Claude, even via Bedrock/Vertex/Azure. + ("litellm.llms.anthropic.chat.transformation", "AnthropicConfig", False), + ( + "litellm.llms.anthropic.experimental_pass_through.messages.transformation", + "AnthropicMessagesConfig", + False, + ), + ( + "litellm.llms.bedrock.claude_platform.transformation", + "BedrockClaudePlatformConfig", + False, + ), + ( + "litellm.llms.vertex_ai.vertex_ai_partner_models.anthropic.transformation", + "VertexAIAnthropicConfig", + False, + ), + ("litellm.llms.azure_ai.anthropic.transformation", "AzureAnthropicConfig", False), + # Non-Claude Anthropic-compatible endpoints strip the false self-description. + ("litellm.llms.minimax.messages.transformation", "MinimaxMessagesConfig", True), + ( + "litellm.llms.deepseek.messages.transformation", + "DeepSeekAnthropicMessagesConfig", + True, + ), + ( + "litellm.llms.tencent.messages.transformation", + "TencentAnthropicMessagesConfig", + True, + ), + ], +) +def test_should_strip_claude_code_identity_by_provider( + module_path, class_name, expected_strip +): + import importlib + + config_cls = getattr(importlib.import_module(module_path), class_name) + assert config_cls().should_strip_claude_code_identity() is expected_strip + + +def _system_with_identity_block(identity_sentence: str) -> list: + return [ + { + "role": "system", + "content": [ + # Claude Code sends the identity sentence as its own text block. + {"type": "text", "text": identity_sentence}, + {"type": "text", "text": "real system prompt"}, + ], + } + ] + + +def test_messages_request_strips_claude_code_identity_for_minimax(): + from litellm.llms.minimax.messages.transformation import MinimaxMessagesConfig + from litellm.types.router import GenericLiteLLMParams + + config = MinimaxMessagesConfig() + assert config.should_strip_claude_code_identity() is True + + optional_params = { + "max_tokens": 16, + "system": [ + {"type": "text", "text": "You are Claude Code, Anthropic's official CLI for Claude."}, + {"type": "text", "text": "real system prompt"}, + ], + } + result = config.transform_anthropic_messages_request( + model="MiniMax-M2", + messages=[{"role": "user", "content": "hi"}], + anthropic_messages_optional_request_params=optional_params, + litellm_params=GenericLiteLLMParams(), + headers={}, + ) + + texts = [block["text"] for block in result.get("system", [])] + assert "You are Claude Code, Anthropic's official CLI for Claude." not in texts + assert "real system prompt" in texts + + +def test_messages_request_keeps_claude_code_identity_for_first_party(): + from litellm.llms.anthropic.experimental_pass_through.messages.transformation import ( + AnthropicMessagesConfig, + ) + from litellm.types.router import GenericLiteLLMParams + + config = AnthropicMessagesConfig() + assert config.should_strip_claude_code_identity() is False + + optional_params = { + "max_tokens": 16, + "system": [ + {"type": "text", "text": "You are Claude Code, Anthropic's official CLI for Claude."}, + {"type": "text", "text": "real system prompt"}, + ], + } + result = config.transform_anthropic_messages_request( + model="claude-3-5-sonnet-latest", + messages=[{"role": "user", "content": "hi"}], + anthropic_messages_optional_request_params=optional_params, + litellm_params=GenericLiteLLMParams(), + headers={}, + ) + + texts = [block["text"] for block in result.get("system", [])] + assert "You are Claude Code, Anthropic's official CLI for Claude." in texts + assert "real system prompt" in texts + + def test_namespace_tool_flat_nested_tools_are_extracted(): """Codex sends nested tools in flat format {type, name, description, parameters} with no 'function' wrapper. These must be normalized and mapped without raising KeyError: 'function'.""" diff --git a/tests/test_litellm/llms/anthropic/test_anthropic_common_utils.py b/tests/test_litellm/llms/anthropic/test_anthropic_common_utils.py index 945033c5cac..62a6753a482 100644 --- a/tests/test_litellm/llms/anthropic/test_anthropic_common_utils.py +++ b/tests/test_litellm/llms/anthropic/test_anthropic_common_utils.py @@ -53,6 +53,30 @@ def test_is_claude_code_one_shot_subagent_request(messages, system, expected): ) +@pytest.mark.parametrize( + "text,expected", + [ + # Identity sentence alone -> drop the whole block. + ("You are Claude Code, Anthropic's official CLI for Claude.", None), + # Identity sentence followed by the rest of the system prompt -> keep the rest. + ( + "You are Claude Code, Anthropic's official CLI for Claude.\nYou are an interactive agent.", + "You are an interactive agent.", + ), + # Leading/trailing whitespace around the bare sentence is treated as drop-only. + (" You are Claude Code, Anthropic's official CLI for Claude. ", None), + # Non-Claude-Code prompts are untouched. + ("You are a helpful assistant.", "You are a helpful assistant."), + # A sentence that merely mentions Claude Code is untouched. + ("You are Claude Code's helper.", "You are Claude Code's helper."), + ], +) +def test_strip_claude_code_identity(text, expected): + from litellm.llms.anthropic.common_utils import strip_claude_code_identity + + assert strip_claude_code_identity(text) == expected + + class TestOptionallyHandleAnthropicOAuth: """Tests for optionally_handle_anthropic_oauth function."""