diff --git a/litellm/llms/sap/chat/models.py b/litellm/llms/sap/chat/models.py index 5f65c7f715d..babe8aa3d0c 100644 --- a/litellm/llms/sap/chat/models.py +++ b/litellm/llms/sap/chat/models.py @@ -2,31 +2,44 @@ import warnings from enum import Enum from typing import Final, Literal -from pydantic import BaseModel, Field, field_validator, model_validator +from pydantic import ( + BaseModel, + Field, + SerializationInfo, + SerializerFunctionWrapHandler, + field_validator, + model_serializer, + model_validator, +) -def validate_different_content(v: str | dict | list) -> str: - if v in ((), {}, []): - return "" - elif isinstance(v, dict) and "text" in v: - return v["text"] - elif isinstance(v, list): - new_v: Final = [] - for item in v: - if isinstance(item, dict) and "text" in item: - if item["text"]: - new_v.append(item["text"]) - elif isinstance(item, str): - new_v.append(item) - return "\n".join(new_v) - elif isinstance(v, str): - return v - raise ValueError("Content must be a string") +class CacheControl(BaseModel): + type: Literal["ephemeral"] + ttl: str | None = None + + @model_serializer(mode="wrap") + def _serialize( + self, handler: SerializerFunctionWrapHandler, info: SerializationInfo + ) -> dict: # mutable-ok: pydantic serializer contract requires bare dict return + result = handler(self) + if result.get("ttl") is None: + result.pop("ttl", None) + return result class TextContent(BaseModel): type_: Literal["text"] = Field(default="text", alias="type") text: str + cache_control: CacheControl | None = None + + @model_serializer(mode="wrap") + def _serialize( + self, handler: SerializerFunctionWrapHandler, info: SerializationInfo + ) -> dict: # mutable-ok: pydantic serializer contract requires bare dict return + result = handler(self) + if result.get("cache_control") is None: + result.pop("cache_control", None) + return result class ImageURLContent(BaseModel): @@ -37,6 +50,16 @@ class ImageURLContent(BaseModel): class ImageContent(BaseModel): type_: Literal["image_url"] = Field(default="image_url", alias="type") image_url: ImageURLContent + cache_control: CacheControl | None = None + + @model_serializer(mode="wrap") + def _serialize( + self, handler: SerializerFunctionWrapHandler, info: SerializationInfo + ) -> dict: # mutable-ok: pydantic serializer contract requires bare dict return + result = handler(self) + if result.get("cache_control") is None: + result.pop("cache_control", None) + return result class FunctionObj(BaseModel): @@ -50,9 +73,9 @@ class FunctionTool(BaseModel): parameters: dict = {"type": "object", "properties": {}} strict: bool = False - def model_dump(self, **kwargs) -> dict: + def model_dump(self, **kwargs: object) -> dict: kwargs["exclude_unset"] = False - return super().model_dump(**kwargs) + return super().model_dump(**kwargs) # pyright: ignore[reportArgumentType] # kwargs forwarded verbatim to pydantic model_dump @field_validator("parameters", mode="before") @classmethod @@ -70,10 +93,14 @@ class FunctionTool(BaseModel): class ChatCompletionTool(BaseModel): type_: Literal["function"] = Field(default="function", alias="type") function: FunctionTool + cache_control: CacheControl | None = None - def model_dump(self, **kwargs) -> dict: + def model_dump(self, **kwargs: object) -> dict: kwargs["exclude_unset"] = False - return super().model_dump(**kwargs) + result = super().model_dump(**kwargs) # pyright: ignore[reportArgumentType] # kwargs forwarded verbatim to pydantic model_dump + if result.get("cache_control") is None: + result.pop("cache_control", None) + return result class MessageToolCall(BaseModel): @@ -88,9 +115,7 @@ class SAPMessage(BaseModel): """ role: Literal["system", "developer"] = "system" - content: str - - _content_validator = field_validator("content", mode="before")(validate_different_content) + content: str | TextContent | list[TextContent] class SAPUserMessage(BaseModel): @@ -100,19 +125,15 @@ class SAPUserMessage(BaseModel): class SAPAssistantMessage(BaseModel): role: Literal["assistant"] = "assistant" - content: str = "" + content: str | TextContent | list[TextContent] = "" refusal: str = "" tool_calls: list[MessageToolCall] = [] - _content_validator = field_validator("content", mode="before")(validate_different_content) - class SAPToolChatMessage(BaseModel): role: Literal["tool"] = "tool" tool_call_id: str - content: str - - _content_validator = field_validator("content", mode="before")(validate_different_content) + content: str | TextContent | list[TextContent] ChatMessage = SAPMessage | SAPUserMessage | SAPAssistantMessage | SAPToolChatMessage diff --git a/litellm/llms/sap/chat/transformation.py b/litellm/llms/sap/chat/transformation.py index d64d7a57281..52745cd4766 100755 --- a/litellm/llms/sap/chat/transformation.py +++ b/litellm/llms/sap/chat/transformation.py @@ -31,6 +31,7 @@ from .handler import ( ) from .models import ( ChatCompletionTool, + ChatMessage, OrchestrationRequest, ResponseFormat, ResponseFormatJSONSchema, @@ -53,50 +54,65 @@ _SAP_MODEL_PARAMS_EXCLUDED_KEYS: Final[frozenset[str]] = frozenset( ) -def validate_dict(data: dict, model) -> dict: +def validate_dict( + data: dict, model: type +) -> dict: # mutable-ok: pydantic validation boundary; both input and output are untyped wire dicts return model(**data).model_dump(by_alias=True, exclude_unset=True) -def _messages_to_sap_template(messages: list[dict[str, str]]) -> list: +def _fold_message_cache_control( + message: dict[str, object], +) -> dict[str, object]: + """Move a message-level cache_control marker onto the content block. + + litellm's cache_control_injection_points hook attaches cache_control to the + message dict itself when content is a plain string. The SAP message models + have no such top-level field, so it would be silently dropped. When content + is a string, promote it to a one-element list so the marker survives. + When content is already a non-empty list whose last element is a + dict, propagate the marker onto that element — it marks the cache + breakpoint for the whole block. In all other cases (empty list, None, + unrecognized type) the marker is silently dropped. + """ + cc = message.get("cache_control") + if cc is None: + return message + base = { + k: v for k, v in message.items() if k != "cache_control" + } # mutable-ok: new dict built from message; returned immediately + content = message.get("content") + if isinstance(content, str): + base["content"] = [ + {"type": "text", "text": content, "cache_control": cc} + ] # mutable-ok: new list+dict built and assigned to output dict + return base + if isinstance(content, list) and content and isinstance(content[-1], dict): + base["content"] = [ + *content[:-1], + {**content[-1], "cache_control": cc}, + ] # mutable-ok: new list+dict built and assigned to output dict + return base + return base + + +def _message_role_mapping(role: str) -> type[ChatMessage]: # returns the SAP message model class, not an instance + return { # mutable-ok: ephemeral dispatch dict; not stored + "user": SAPUserMessage, + "assistant": SAPAssistantMessage, + "tool": SAPToolChatMessage, + }.get(role, SAPMessage) + + +def _messages_to_sap_template(messages: list[dict[str, object]]) -> list: template: Final = [] for message in messages: - if message["role"] == "user": - template.append(validate_dict(message, SAPUserMessage)) - elif message["role"] == "assistant": - template.append(validate_dict(message, SAPAssistantMessage)) - elif message["role"] == "tool": - template.append(validate_dict(message, SAPToolChatMessage)) - else: - template.append(validate_dict(message, SAPMessage)) + folded_message = _fold_message_cache_control(message) + message_role_class = _message_role_mapping(str(folded_message["role"])) + validated_message = validate_dict(folded_message, message_role_class) + template.append(validated_message) return template -def _tools_response_format_and_stream(optional_params: dict, model_params: dict) -> tuple[dict, dict, dict]: - tools_ = optional_params.pop("tools", []) - tools_ = [validate_dict(tool, ChatCompletionTool) for tool in tools_] - tools: Final[dict] = {"tools": tools_} if tools_ else {} - - response_format = model_params.pop("response_format", {}) - resp_type: Final = response_format.get("type", None) - if resp_type: - if resp_type == "json_schema": - response_format = validate_dict(response_format, ResponseFormatJSONSchema) - else: - response_format = validate_dict(response_format, ResponseFormat) - response_format = {"response_format": response_format} - - model_params.pop("stream", False) - stream_config: Final[dict] = {} - if "stream_options" in optional_params: - stream_options: Final = optional_params.pop("stream_options", {}) - if "chunk_size" in stream_options: - stream_config["chunk_size"] = stream_options.get("chunk_size") - if "delimiters" in stream_options: - stream_config["delimiters"] = stream_options.get("delimiters") - - return tools, response_format, stream_config - - class GenAIHubOrchestrationConfig(OpenAIGPTConfig): frequency_penalty: int | None = None function_call: str | dict | None = None @@ -432,6 +448,6 @@ class GenAIHubOrchestrationConfig(OpenAIGPTConfig): json_mode: bool | None = False, ): if sync_stream: - return SAPStreamIterator(response=streaming_response) + return SAPStreamIterator(response=streaming_response) # pyright: ignore[reportArgumentType] # streaming_response type matches at runtime else: - return AsyncSAPStreamIterator(response=streaming_response) + return AsyncSAPStreamIterator(response=streaming_response) # pyright: ignore[reportArgumentType] # streaming_response type matches at runtime diff --git a/tests/test_litellm/llms/sap/chat/test_sap_models.py b/tests/test_litellm/llms/sap/chat/test_sap_models.py new file mode 100644 index 00000000000..bb38ee35253 --- /dev/null +++ b/tests/test_litellm/llms/sap/chat/test_sap_models.py @@ -0,0 +1,221 @@ +import pytest +from pydantic import ValidationError + +from litellm.llms.sap.chat.models import ( + SAPAssistantMessage, + SAPMessage, + SAPToolChatMessage, + SAPUserMessage, + TextContent, +) + + +class TestSAPMessage: + def test_role_system(self): + msg = SAPMessage.model_validate({"role": "system", "content": "Hi"}) + assert msg.role == "system" + + def test_role_developer(self): + msg = SAPMessage.model_validate({"role": "developer", "content": "Hi"}) + assert msg.role == "developer" + + def test_role_defaults_to_system(self): + msg = SAPMessage.model_validate({"content": "Hi"}) + assert msg.role == "system" + + def test_invalid_role_rejected(self): + with pytest.raises(ValidationError): + SAPMessage.model_validate({"role": "user", "content": "Hi"}) + + def test_missing_content_rejected(self): + with pytest.raises(ValidationError): + SAPMessage.model_validate({"role": "system"}) + + def test_string_content_accepted(self): + msg = SAPMessage.model_validate({"role": "system", "content": "Hello"}) + assert msg.content == "Hello" + + def test_text_content_block_accepted(self): + msg = SAPMessage.model_validate({"role": "system", "content": {"type": "text", "text": "Hello"}}) + assert isinstance(msg.content, TextContent) + assert msg.content.text == "Hello" + + def test_list_of_text_content_blocks_accepted(self): + msg = SAPMessage.model_validate({ + "role": "system", + "content": [{"type": "text", "text": "A"}, {"type": "text", "text": "B"}], + }) + assert isinstance(msg.content, list) + assert len(msg.content) == 2 + assert isinstance(msg.content[0], TextContent) + + def test_invalid_content_type_rejected(self): + with pytest.raises(ValidationError): + SAPMessage.model_validate({"role": "system", "content": 123}) + + def test_cache_control_on_content_block(self): + msg = SAPMessage.model_validate({ + "role": "system", + "content": {"type": "text", "text": "Hi", "cache_control": {"type": "ephemeral"}}, + }) + assert isinstance(msg.content, TextContent) + assert msg.content.cache_control is not None + assert msg.content.cache_control.type == "ephemeral" + + +class TestSAPUserMessage: + def test_role_is_always_user(self): + msg = SAPUserMessage.model_validate({"content": "Hi"}) + assert msg.role == "user" + + def test_invalid_role_rejected(self): + with pytest.raises(ValidationError): + SAPUserMessage.model_validate({"role": "system", "content": "Hi"}) + + def test_missing_content_rejected(self): + with pytest.raises(ValidationError): + SAPUserMessage.model_validate({}) + + def test_string_content_accepted(self): + msg = SAPUserMessage.model_validate({"content": "Hello"}) + assert msg.content == "Hello" + + def test_text_content_block_accepted(self): + msg = SAPUserMessage.model_validate({"content": {"type": "text", "text": "Hello"}}) + assert isinstance(msg.content, TextContent) + + def test_image_content_accepted(self): + from litellm.llms.sap.chat.models import ImageContent + + msg = SAPUserMessage.model_validate({ + "content": {"type": "image_url", "image_url": {"url": "https://example.com/img.png"}} + }) + assert isinstance(msg.content, ImageContent) + + def test_mixed_list_of_text_and_image_accepted(self): + msg = SAPUserMessage.model_validate({ + "content": [ + {"type": "text", "text": "Look at this:"}, + {"type": "image_url", "image_url": {"url": "https://example.com/img.png"}}, + ] + }) + assert isinstance(msg.content, list) + assert len(msg.content) == 2 + + def test_invalid_content_type_rejected(self): + with pytest.raises(ValidationError): + SAPUserMessage.model_validate({"content": 123}) + + def test_cache_control_on_content_block(self): + msg = SAPUserMessage.model_validate({ + "content": {"type": "text", "text": "Hi", "cache_control": {"type": "ephemeral"}}, + }) + assert isinstance(msg.content, TextContent) + assert msg.content.cache_control is not None + assert msg.content.cache_control.type == "ephemeral" + + +class TestSAPAssistantMessage: + def test_role_is_always_assistant(self): + msg = SAPAssistantMessage.model_validate({"content": "Hi"}) + assert msg.role == "assistant" + + def test_invalid_role_rejected(self): + with pytest.raises(ValidationError): + SAPAssistantMessage.model_validate({"role": "user", "content": "Hi"}) + + def test_refusal_defaults_to_empty_string(self): + msg = SAPAssistantMessage.model_validate({}) + assert msg.refusal == "" + + def test_refusal_accepted(self): + msg = SAPAssistantMessage.model_validate({"refusal": "I cannot help with that."}) + assert msg.refusal == "I cannot help with that." + + def test_tool_calls_default_to_empty_list(self): + msg = SAPAssistantMessage.model_validate({}) + assert msg.tool_calls == [] + + def test_string_content_accepted(self): + msg = SAPAssistantMessage.model_validate({"content": "Hello"}) + assert msg.content == "Hello" + + def test_default_empty_string(self): + msg = SAPAssistantMessage.model_validate({}) + assert msg.content == "" + + def test_text_content_block_accepted(self): + msg = SAPAssistantMessage.model_validate({"content": {"type": "text", "text": "Hello"}}) + assert isinstance(msg.content, TextContent) + + def test_list_of_text_blocks_accepted(self): + msg = SAPAssistantMessage.model_validate({ + "content": [{"type": "text", "text": "A"}, {"type": "text", "text": "B"}] + }) + assert isinstance(msg.content, list) + assert len(msg.content) == 2 + + def test_invalid_content_type_rejected(self): + with pytest.raises(ValidationError): + SAPAssistantMessage.model_validate({"content": {"type": "image_url", "image_url": {"url": "x"}}}) + + def test_cache_control_on_content_block(self): + msg = SAPAssistantMessage.model_validate({ + "content": {"type": "text", "text": "Hi", "cache_control": {"type": "ephemeral"}}, + }) + assert isinstance(msg.content, TextContent) + assert msg.content.cache_control is not None + assert msg.content.cache_control.type == "ephemeral" + + +class TestSAPToolChatMessage: + def test_role_is_always_tool(self): + msg = SAPToolChatMessage.model_validate({"tool_call_id": "call_1", "content": "ok"}) + assert msg.role == "tool" + + def test_invalid_role_rejected(self): + with pytest.raises(ValidationError): + SAPToolChatMessage.model_validate({"role": "user", "tool_call_id": "call_1", "content": "ok"}) + + def test_tool_call_id_accepted(self): + msg = SAPToolChatMessage.model_validate({"tool_call_id": "call_abc123", "content": "result"}) + assert msg.tool_call_id == "call_abc123" + + def test_missing_tool_call_id_rejected(self): + with pytest.raises(ValidationError): + SAPToolChatMessage.model_validate({"content": "result"}) + + def test_string_content_accepted(self): + msg = SAPToolChatMessage.model_validate({"tool_call_id": "call_1", "content": "result"}) + assert msg.content == "result" + + def test_text_content_block_accepted(self): + msg = SAPToolChatMessage.model_validate({ + "tool_call_id": "call_1", "content": {"type": "text", "text": "result"} + }) + assert isinstance(msg.content, TextContent) + + def test_list_of_text_blocks_accepted(self): + msg = SAPToolChatMessage.model_validate({ + "tool_call_id": "call_1", + "content": [{"type": "text", "text": "A"}, {"type": "text", "text": "B"}], + }) + assert isinstance(msg.content, list) + assert len(msg.content) == 2 + + def test_missing_content_rejected(self): + with pytest.raises(ValidationError): + SAPToolChatMessage.model_validate({"tool_call_id": "call_1"}) + + def test_invalid_content_type_rejected(self): + with pytest.raises(ValidationError): + SAPToolChatMessage.model_validate({"tool_call_id": "call_1", "content": 99}) + + def test_cache_control_on_content_block(self): + msg = SAPToolChatMessage.model_validate({ + "tool_call_id": "call_1", + "content": {"type": "text", "text": "result", "cache_control": {"type": "ephemeral"}}, + }) + assert isinstance(msg.content, TextContent) + assert msg.content.cache_control is not None + assert msg.content.cache_control.type == "ephemeral" diff --git a/tests/test_litellm/llms/sap/chat/test_sap_transformation.py b/tests/test_litellm/llms/sap/chat/test_sap_transformation.py index 3601bdd0d5e..d54dc02ff57 100644 --- a/tests/test_litellm/llms/sap/chat/test_sap_transformation.py +++ b/tests/test_litellm/llms/sap/chat/test_sap_transformation.py @@ -1,4 +1,5 @@ import warnings + import pytest from pydantic import ValidationError @@ -611,31 +612,332 @@ class TestSAPTransformationIntegration: assert translation["input"]["config"]["source_language"] == "en-US" assert translation["input"]["config"]["target_language"] == "de-DE" assert translation["output"]["config"]["target_language"] == "fr-FR" + assert config["config"]["modules"][1]["prompt_templating"]["model"]["name"] == "gpt-5" + assert config["config"]["modules"][0]["prompt_templating"]["model"]["name"] == "gpt-4o" + assert config["config"]["modules"][0]["prompt_templating"]["model"]["params"] == {} assert ( - config["config"]["modules"][1]["prompt_templating"]["model"]["name"] - == "gpt-5" - ) - assert ( - config["config"]["modules"][0]["prompt_templating"]["model"]["name"] - == "gpt-4o" - ) - assert ( - config["config"]["modules"][0]["prompt_templating"]["model"]["params"] - == {} - ) - assert ( - config["config"]["modules"][1]["prompt_templating"]["prompt"][ - "template" - ][0]["content"] + config["config"]["modules"][1]["prompt_templating"]["prompt"]["template"][0]["content"] == "Hello world!" ) - assert ( - config["config"]["modules"][0]["prompt_templating"]["prompt"][ - "template" - ][0]["content"] - == "Hello." - ) - assert ( - config["config"]["modules"][1]["translation"]["input"]["type"] - == "sap_document_translation" - ) + assert config["config"]["modules"][0]["prompt_templating"]["prompt"]["template"][0]["content"] == "Hello." + assert config["config"]["modules"][1]["translation"]["input"]["type"] == "sap_document_translation" + + +class TestCacheControl: + """Unit tests for cache_control preservation on message content parts.""" + + def _transform(self, model: str, messages: list) -> dict: + from litellm.llms.sap.chat.transformation import GenAIHubOrchestrationConfig + + cfg = GenAIHubOrchestrationConfig() + return cfg.transform_request( + model=model, + messages=messages, + optional_params={}, + litellm_params={}, + headers={}, + ) + + def _template(self, body: dict) -> list: + return body["config"]["modules"]["prompt_templating"]["prompt"]["template"] + + def test_cache_control_preserved_on_text_content(self): + """cache_control on a TextContent part survives validation and appears in payload.""" + messages = [ + { + "role": "user", + "content": [ + { + "type": "text", + "text": "Hello", + "cache_control": {"type": "ephemeral"}, + } + ], + } + ] + body = self._transform("anthropic--claude-3-5-sonnet", messages) + template = self._template(body) + content = template[0]["content"] + assert isinstance(content, list) + assert content[0].get("cache_control") == {"type": "ephemeral"} + + def test_plain_text_content_unaffected(self): + """Text content without cache_control still serialises cleanly.""" + messages = [{"role": "user", "content": "Hello"}] + body = self._transform("anthropic--claude-3-5-sonnet", messages) + template = self._template(body) + assert template[0]["content"] == "Hello" + + def test_cache_control_preserved_on_multiple_parts(self): + """cache_control is preserved on each part independently.""" + messages = [ + { + "role": "user", + "content": [ + {"type": "text", "text": "Part A", "cache_control": {"type": "ephemeral"}}, + {"type": "text", "text": "Part B"}, + ], + } + ] + body = self._transform("anthropic--claude-3-5-sonnet", messages) + content = self._template(body)[0]["content"] + assert content[0].get("cache_control") == {"type": "ephemeral"} + assert "cache_control" not in content[1] + + def test_cache_control_preserved_on_system_message(self): + """cache_control on a system message content part reaches the payload.""" + messages = [ + { + "role": "system", + "content": [ + { + "type": "text", + "text": "You are a helpful assistant.", + "cache_control": {"type": "ephemeral"}, + } + ], + }, + {"role": "user", "content": "Hello"}, + ] + body = self._transform("anthropic--claude-3-5-sonnet", messages) + template = self._template(body) + system_content = template[0]["content"] + assert isinstance(system_content, list) + assert system_content[0].get("cache_control") == {"type": "ephemeral"} + + def test_system_message_without_cache_control_stays_string(self): + """A plain system message is still serialised as a string, not a list.""" + messages = [ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": "Hello"}, + ] + body = self._transform("anthropic--claude-3-5-sonnet", messages) + template = self._template(body) + assert isinstance(template[0]["content"], str) + + def test_cache_control_preserved_on_tool_definition(self): + """cache_control on a tool definition reaches the payload.""" + tool = { + "type": "function", + "function": { + "name": "get_weather", + "description": "Get weather", + "parameters": {"type": "object", "properties": {}}, + }, + "cache_control": {"type": "ephemeral"}, + } + messages = [{"role": "user", "content": "Hi"}] + from litellm.llms.sap.chat.transformation import GenAIHubOrchestrationConfig + + cfg = GenAIHubOrchestrationConfig() + body = cfg.transform_request( + model="anthropic--claude-3-5-sonnet", + messages=messages, + optional_params={"tools": [tool]}, + litellm_params={}, + headers={}, + ) + tools = body["config"]["modules"]["prompt_templating"]["prompt"]["tools"] + assert tools[0].get("cache_control") == {"type": "ephemeral"} + + def test_tool_without_cache_control_omits_field(self): + """A tool without cache_control does not emit cache_control: null.""" + tool = { + "type": "function", + "function": { + "name": "get_weather", + "description": "Get weather", + "parameters": {"type": "object", "properties": {}}, + }, + } + messages = [{"role": "user", "content": "Hi"}] + from litellm.llms.sap.chat.transformation import GenAIHubOrchestrationConfig + + cfg = GenAIHubOrchestrationConfig() + body = cfg.transform_request( + model="anthropic--claude-3-5-sonnet", + messages=messages, + optional_params={"tools": [tool]}, + litellm_params={}, + headers={}, + ) + tools = body["config"]["modules"]["prompt_templating"]["prompt"]["tools"] + assert "cache_control" not in tools[0] + + def test_message_level_cache_control_folded_onto_string_content(self): + """cache_control on the message dict (string content) is folded into a content block. + + litellm's cache_control_injection_points hook produces this shape for + plain-string content. The marker must not be silently dropped. + """ + messages = [ + { + "role": "system", + "content": "You are a helpful assistant.", + "cache_control": {"type": "ephemeral"}, + }, + {"role": "user", "content": "Hello"}, + ] + body = self._transform("anthropic--claude-3-5-sonnet", messages) + template = self._template(body) + system_content = template[0]["content"] + assert isinstance(system_content, list), "string content should have been promoted to a list" + assert system_content[0]["text"] == "You are a helpful assistant." + assert system_content[0].get("cache_control") == {"type": "ephemeral"} + + def test_null_cache_control_on_content_block_is_omitted(self): + """cache_control: null on a content block must not appear in the payload. + + Sending null reaches AI Core and causes a 400 ('None is not of type object'). + """ + messages = [ + { + "role": "user", + "content": [ + {"type": "text", "text": "Hello", "cache_control": None}, + ], + } + ] + body = self._transform("anthropic--claude-3-5-sonnet", messages) + content = self._template(body)[0]["content"] + assert isinstance(content, list) + assert "cache_control" not in content[0] + + def test_message_level_cache_control_folded_on_user_message(self): + """cache_control on the message dict (string user content) is folded into a content block. + + The injection hook can attach cache_control at the message level for any role. + User messages must receive the same folding treatment as system messages. + """ + messages = [ + { + "role": "user", + "content": "What is the weather today?", + "cache_control": {"type": "ephemeral"}, + } + ] + body = self._transform("anthropic--claude-3-5-sonnet", messages) + content = self._template(body)[0]["content"] + assert isinstance(content, list), "string content should have been promoted to a list" + assert content[0]["text"] == "What is the weather today?" + assert content[0].get("cache_control") == {"type": "ephemeral"} + + def test_cache_control_ttl_omitted_when_absent(self): + """cache_control without ttl must not emit ttl: null in the payload.""" + messages = [ + { + "role": "user", + "content": [ + {"type": "text", "text": "Hello", "cache_control": {"type": "ephemeral"}}, + ], + } + ] + body = self._transform("anthropic--claude-3-5-sonnet", messages) + cc = self._template(body)[0]["content"][0]["cache_control"] + assert cc == {"type": "ephemeral"} + assert "ttl" not in cc + + def test_cache_control_ttl_preserved_when_set(self): + """cache_control with ttl must include ttl in the payload.""" + messages = [ + { + "role": "user", + "content": [ + {"type": "text", "text": "Hello", "cache_control": {"type": "ephemeral", "ttl": "300"}}, + ], + } + ] + body = self._transform("anthropic--claude-3-5-sonnet", messages) + cc = self._template(body)[0]["content"][0]["cache_control"] + assert cc == {"type": "ephemeral", "ttl": "300"} + + def test_message_level_cache_control_folded_on_assistant_message(self): + """cache_control on an assistant turn is folded into a content block.""" + messages = [ + {"role": "user", "content": "Hi"}, + { + "role": "assistant", + "content": "Hello! How can I help?", + "cache_control": {"type": "ephemeral"}, + }, + {"role": "user", "content": "Continue"}, + ] + body = self._transform("anthropic--claude-3-5-sonnet", messages) + template = self._template(body) + assistant_content = template[1]["content"] + assert isinstance(assistant_content, list), "string content should have been promoted to a list" + assert assistant_content[0]["text"] == "Hello! How can I help?" + assert assistant_content[0].get("cache_control") == {"type": "ephemeral"} + + def test_message_level_cache_control_folded_on_tool_message(self): + """cache_control on a tool result is folded into a content block.""" + messages = [ + {"role": "user", "content": "What is the weather?"}, + { + "role": "assistant", + "content": "", + "tool_calls": [ + { + "id": "call_1", + "type": "function", + "function": {"name": "get_weather", "arguments": "{}"}, + } + ], + }, + { + "role": "tool", + "tool_call_id": "call_1", + "content": "Sunny, 22C", + "cache_control": {"type": "ephemeral"}, + }, + ] + body = self._transform("anthropic--claude-3-5-sonnet", messages) + template = self._template(body) + tool_content = template[2]["content"] + assert isinstance(tool_content, list), "string content should have been promoted to a list" + assert tool_content[0]["text"] == "Sunny, 22C" + assert tool_content[0].get("cache_control") == {"type": "ephemeral"} + + def test_message_level_cache_control_folded_onto_last_list_element(self): + """A top-level cache_control with list content marks the last element. + + Per the Anthropic spec, a message-level marker indicates the cache + breakpoint for the whole block. It must land on the final content + part, not be silently dropped. + """ + messages = [ + { + "role": "user", + "content": [ + {"type": "text", "text": "Part A"}, + {"type": "text", "text": "Part B"}, + ], + "cache_control": {"type": "ephemeral"}, + } + ] + body = self._transform("anthropic--claude-3-5-sonnet", messages) + content = self._template(body)[0]["content"] + assert "cache_control" not in content[0] + assert content[1].get("cache_control") == {"type": "ephemeral"} + + def test_message_level_cache_control_folded_onto_trailing_image_block(self): + """A top-level cache_control with a trailing image part lands on that image. + + The Anthropic spec allows cache_control on any content block including + image_url. Previously ImageContent had no cache_control field, so the + marker was silently dropped by Pydantic validation. + """ + messages = [ + { + "role": "user", + "content": [ + {"type": "text", "text": "Describe this image."}, + {"type": "image_url", "image_url": {"url": "data:image/png;base64,abc="}}, + ], + "cache_control": {"type": "ephemeral"}, + } + ] + body = self._transform("anthropic--claude-3-5-sonnet", messages) + content = self._template(body)[0]["content"] + assert "cache_control" not in content[0] + assert content[1].get("cache_control") == {"type": "ephemeral"}