diff --git a/litellm/responses/litellm_completion_transformation/transformation.py b/litellm/responses/litellm_completion_transformation/transformation.py index bd239922fd3..3c5a69dc5e0 100644 --- a/litellm/responses/litellm_completion_transformation/transformation.py +++ b/litellm/responses/litellm_completion_transformation/transformation.py @@ -1421,14 +1421,21 @@ class LiteLLMCompletionResponsesConfig: # Since guardrails skip None content anyway, we return empty list to exclude it from structured messages if content is None: return [] - return [ - GenericChatCompletionMessage( - role=_input_item_role(input_item), - content=LiteLLMCompletionResponsesConfig._transform_responses_api_content_to_chat_completion_content( - content - ), - ) - ] + msg = GenericChatCompletionMessage( + role=input_item.get("role") or "user", + content=LiteLLMCompletionResponsesConfig._transform_responses_api_content_to_chat_completion_content( + content + ), + ) + if input_item.get("cache_control"): + msg["cache_control"] = input_item.get("cache_control") + # Also propagate to the last content element for providers + # that read cache_control from content blocks (Anthropic, Bedrock) + if isinstance(msg["content"], list) and len(msg["content"]) > 0: + last_element = msg["content"][-1] + if isinstance(last_element, dict): + last_element["cache_control"] = input_item["cache_control"] + return [msg] @staticmethod def _reasoning_text_from_content(input_item: Mapping[str, object]) -> str | None: @@ -1646,6 +1653,9 @@ class LiteLLMCompletionResponsesConfig: content=_normalize_function_call_output_to_tool_content(tool_call_output.get("output")), tool_call_id=str(call_id), ) + output_cache_control = tool_call_output.get("cache_control") + if output_cache_control: + tool_output_message["cache_control"] = output_cache_control _tool_use_definition: Final = TOOL_CALLS_CACHE.get_cache( key=tool_call_output.get("call_id") or "", @@ -1742,6 +1752,9 @@ class LiteLLMCompletionResponsesConfig: role="assistant", content=None, # Function calls don't have content ) + function_call_cache_control = function_call.get("cache_control") + if function_call_cache_control: + chat_completion_response_message["cache_control"] = function_call_cache_control return [chat_completion_response_message] diff --git a/litellm/types/llms/openai.py b/litellm/types/llms/openai.py index 99ab5920c4f..b8607f68e69 100644 --- a/litellm/types/llms/openai.py +++ b/litellm/types/llms/openai.py @@ -878,6 +878,7 @@ class ChatCompletionToolMessage(TypedDict): role: Literal["tool"] content: str | Iterable[ToolMessageContentPart] # writable-ok: Pydantic warns on ReadOnly TypedDict fields tool_call_id: str + cache_control: NotRequired[ChatCompletionCachedContent] class ChatCompletionFunctionMessage(TypedDict): @@ -910,6 +911,7 @@ class ChatCompletionDeveloperMessage(OpenAIChatCompletionDeveloperMessage, total class GenericChatCompletionMessage(TypedDict, total=False): role: Required[str] content: Required[str | list] + cache_control: ChatCompletionCachedContent ValidUserMessageContentTypes = [ @@ -1100,6 +1102,7 @@ class ChatCompletionResponseMessage(TypedDict, total=False): provider_specific_fields: dict | None reasoning_content: str | None thinking_blocks: list[ChatCompletionThinkingBlock | ChatCompletionRedactedThinkingBlock] | None + cache_control: ChatCompletionCachedContent class ChatCompletionUsageBlock(TypedDict, total=False): diff --git a/tests/unit/responses/litellm_completion_transformation/test_litellm_completion_responses.py b/tests/unit/responses/litellm_completion_transformation/test_litellm_completion_responses.py index 7b9de4644b4..ab1de8f4946 100644 --- a/tests/unit/responses/litellm_completion_transformation/test_litellm_completion_responses.py +++ b/tests/unit/responses/litellm_completion_transformation/test_litellm_completion_responses.py @@ -5172,3 +5172,133 @@ async def test_bridge_rejects_untranslatable_tool_choice_with_a_400(stream: bool ) assert exc_info.value.status_code == 400 assert "tool_choice={'type': 'file_search'}" in str(exc_info.value) +class TestCacheControlPreservationOnMessages: + """Tests that cache_control is preserved when transforming Responses API input items + to Chat Completion messages. This is critical for providers like Bedrock/Anthropic + that use cache_control for prompt caching.""" + + def test_cache_control_on_user_message(self): + """cache_control on a user message should be passed through to GenericChatCompletionMessage""" + input_item = { + "role": "user", + "content": "Hello, world!", + "cache_control": {"type": "ephemeral"}, + } + + result = LiteLLMCompletionResponsesConfig._transform_responses_api_input_item_to_chat_completion_message( + input_item=input_item + ) + + assert len(result) == 1 + msg = result[0] + assert msg["role"] == "user" + assert msg.get("cache_control") == {"type": "ephemeral"} + + def test_cache_control_on_assistant_message(self): + """cache_control on an assistant message should be passed through""" + input_item = { + "role": "assistant", + "content": "I can help with that.", + "cache_control": {"type": "ephemeral"}, + } + + result = LiteLLMCompletionResponsesConfig._transform_responses_api_input_item_to_chat_completion_message( + input_item=input_item + ) + + assert len(result) == 1 + msg = result[0] + assert msg["role"] == "assistant" + assert msg.get("cache_control") == {"type": "ephemeral"} + + def test_no_cache_control_when_absent(self): + """Messages without cache_control should not have the field set""" + input_item = { + "role": "user", + "content": "Hello", + } + + result = LiteLLMCompletionResponsesConfig._transform_responses_api_input_item_to_chat_completion_message( + input_item=input_item + ) + + assert len(result) == 1 + msg = result[0] + assert "cache_control" not in msg + + def test_cache_control_on_function_call_output(self): + """cache_control on a function_call_output should be passed through to tool message""" + TOOL_CALLS_CACHE.set_cache( + key="call_123", + value={ + "id": "call_123", + "type": "function", + "function": {"name": "get_weather", "arguments": '{"city": "NYC"}'}, + }, + ) + + input_item = { + "type": "function_call_output", + "call_id": "call_123", + "output": '{"temp": 72}', + "cache_control": {"type": "ephemeral"}, + } + + result = LiteLLMCompletionResponsesConfig._transform_responses_api_input_item_to_chat_completion_message( + input_item=input_item + ) + + # Should have assistant message + tool message + assert len(result) == 2 + tool_msg = result[1] + assert tool_msg["role"] == "tool" + assert tool_msg.get("cache_control") == {"type": "ephemeral"} + + def test_cache_control_on_function_call(self): + """cache_control on a function_call input should be passed through to assistant message""" + input_item = { + "type": "function_call", + "call_id": "call_456", + "name": "get_weather", + "arguments": '{"city": "NYC"}', + "cache_control": {"type": "ephemeral"}, + } + + result = LiteLLMCompletionResponsesConfig._transform_responses_api_input_item_to_chat_completion_message( + input_item=input_item + ) + + assert len(result) == 1 + msg = result[0] + assert msg["role"] == "assistant" + assert msg.get("cache_control") == {"type": "ephemeral"} + + def test_cache_control_preserved_in_full_input_transform(self): + """cache_control should survive the full transform_responses_api_input_to_messages path""" + input_items = [ + { + "role": "user", + "content": "What is the weather?", + }, + { + "role": "assistant", + "content": "Let me check.", + "cache_control": {"type": "ephemeral"}, + }, + { + "role": "user", + "content": "Thanks!", + "cache_control": {"type": "ephemeral"}, + }, + ] + + result = LiteLLMCompletionResponsesConfig.transform_responses_api_input_to_messages( + input=input_items, + responses_api_request={}, + ) + + # 3 messages, no system + assert len(result) == 3 + assert "cache_control" not in result[0] + assert result[1].get("cache_control") == {"type": "ephemeral"} + assert result[2].get("cache_control") == {"type": "ephemeral"}