Add comprehensive test coverage for CachePoint feature

- Add test_cache_point_with_streaming to verify CachePoint works with run_stream()
- Add test_cache_point_with_unsupported_type to verify error handling for non-cacheable content types
- Add test_cache_point_in_user_prompt to verify CachePoint is filtered in OpenTelemetry conversion
- Fix test_cache_point_filtering in test_google.py to properly test _map_user_prompt method
- Enhance test_cache_point_filtering in test_openai.py to directly test both Chat and Responses models
- Add test_cache_point_filtering_responses_model for OpenAI Responses API

These tests increase diff coverage from 68% to 98% (100% for all production code).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: ronakrm

tests/models/test_google.py

@@ -3203,12 +3203,17 @@ def _generate_response_with_texts(response_id: str, texts: list[str]) -> Generat
     )
 
 
-def test_cache_point_filtering():
+async def test_cache_point_filtering():
     """Test that CachePoint is filtered out in Google internal method."""
     from pydantic_ai import CachePoint
 
+    # Create a minimal GoogleModel instance to test _map_user_prompt
+    model = GoogleModel('gemini-1.5-flash', provider=GoogleProvider(api_key='test-key'))
+
     # Test that CachePoint in a list is handled (triggers line 606)
-    # We can't easily call _map_user_content without a full model setup,
-    # but we can verify the isinstance check with a simple lambda
-    assert isinstance(CachePoint(), CachePoint)
-    # This ensures the CachePoint class is importable and the isinstance check works
+    content = await model._map_user_prompt(UserPromptPart(content=['text before', CachePoint(), 'text after']))  # pyright: ignore[reportPrivateUsage]
+
+    # CachePoint should be filtered out, only text content should remain
+    assert len(content) == 2
+    assert content[0] == {'text': 'text before'}
+    assert content[1] == {'text': 'text after'}

tests/models/test_instrumented.py

@@ -17,6 +17,7 @@
     BinaryContent,
     BuiltinToolCallPart,
     BuiltinToolReturnPart,
+    CachePoint,
     DocumentUrl,
     FilePart,
     FinalResultEvent,
@@ -1615,3 +1616,78 @@ def test_message_with_builtin_tool_calls():
             }
         ]
     )
+
+
+def test_cache_point_in_user_prompt():
+    """Test that CachePoint is correctly skipped in OpenTelemetry conversion.
+
+    CachePoint is a marker for prompt caching and should not be included in the
+    OpenTelemetry message parts output.
+    """
+    messages: list[ModelMessage] = [
+        ModelRequest(parts=[UserPromptPart(content=['text before', CachePoint(), 'text after'])]),
+    ]
+    settings = InstrumentationSettings()
+
+    # Test otel_message_parts - CachePoint should be skipped
+    assert settings.messages_to_otel_messages(messages) == snapshot(
+        [
+            {
+                'role': 'user',
+                'parts': [
+                    {'type': 'text', 'content': 'text before'},
+                    {'type': 'text', 'content': 'text after'},
+                ],
+            }
+        ]
+    )
+
+    # Test with multiple CachePoints
+    messages_multi = [
+        ModelRequest(
+            parts=[
+                UserPromptPart(content=['first', CachePoint(), 'second', CachePoint(), 'third']),
+            ]
+        ),
+    ]
+    assert settings.messages_to_otel_messages(messages_multi) == snapshot(
+        [
+            {
+                'role': 'user',
+                'parts': [
+                    {'type': 'text', 'content': 'first'},
+                    {'type': 'text', 'content': 'second'},
+                    {'type': 'text', 'content': 'third'},
+                ],
+            }
+        ]
+    )
+
+    # Test with CachePoint mixed with other content types
+    messages_mixed = [
+        ModelRequest(
+            parts=[
+                UserPromptPart(
+                    content=[
+                        'context',
+                        CachePoint(),
+                        ImageUrl('https://example.com/image.jpg'),
+                        CachePoint(),
+                        'question',
+                    ]
+                ),
+            ]
+        ),
+    ]
+    assert settings.messages_to_otel_messages(messages_mixed) == snapshot(
+        [
+            {
+                'role': 'user',
+                'parts': [
+                    {'type': 'text', 'content': 'context'},
+                    {'type': 'image-url', 'url': 'https://example.com/image.jpg'},
+                    {'type': 'text', 'content': 'question'},
+                ],
+            }
+        ]
+    )

tests/models/test_openai.py

@@ -3058,12 +3058,28 @@ def test_deprecated_openai_model(openai_api_key: str):
 
 
 async def test_cache_point_filtering(allow_model_requests: None):
-    """Test that CachePoint is filtered out in OpenAI requests."""
+    """Test that CachePoint is filtered out in OpenAI Chat Completions requests."""
     c = completion_message(ChatCompletionMessage(content='response', role='assistant'))
     mock_client = MockOpenAI.create_mock(c)
     m = OpenAIChatModel('gpt-4o', provider=OpenAIProvider(openai_client=mock_client))
-    agent = Agent(m)
 
-    # Just verify that CachePoint doesn't cause an error - it should be filtered out
-    result = await agent.run(['text before', CachePoint(), 'text after'])
-    assert result.output == 'response'
+    # Test the instance method directly to trigger line 864
+    msg = await m._map_user_prompt(UserPromptPart(content=['text before', CachePoint(), 'text after']))  # pyright: ignore[reportPrivateUsage]
+
+    # CachePoint should be filtered out, only text content should remain
+    assert msg['role'] == 'user'
+    assert len(msg['content']) == 2  # type: ignore[reportUnknownArgumentType]
+    assert msg['content'][0]['text'] == 'text before'  # type: ignore[reportUnknownArgumentType]
+    assert msg['content'][1]['text'] == 'text after'  # type: ignore[reportUnknownArgumentType]
+
+
+async def test_cache_point_filtering_responses_model():
+    """Test that CachePoint is filtered out in OpenAI Responses API requests."""
+    # Test the static method directly to trigger line 1680
+    msg = await OpenAIResponsesModel._map_user_prompt(UserPromptPart(content=['text before', CachePoint(), 'text after']))  # pyright: ignore[reportPrivateUsage]
+
+    # CachePoint should be filtered out, only text content should remain
+    assert msg['role'] == 'user'
+    assert len(msg['content']) == 2  # type: ignore[reportUnknownArgumentType]
+    assert msg['content'][0]['text'] == 'text before'  # type: ignore[reportUnknownArgumentType]
+    assert msg['content'][1]['text'] == 'text after'  # type: ignore[reportUnknownArgumentType]