From 64b37a51c399b493e6849f3425fd5958330d602b Mon Sep 17 00:00:00 2001 From: Zachary Juang Date: Sat, 31 Oct 2026 03:28:50 -0400 Subject: [PATCH] fix --- .../gemini-content-filter-errors.md | 5 + posthog/ai/gemini/gemini_converter.py | 40 ++++++ posthog/ai/utils.py | 38 ++++++ posthog/test/ai/gemini/test_gemini.py | 129 ++++++++++++++++++ posthog/test/ai/gemini/test_gemini_async.py | 26 ++++ 5 files changed, 238 insertions(+) create mode 100644 .sampo/changesets/gemini-content-filter-errors.md diff --git a/.sampo/changesets/gemini-content-filter-errors.md b/.sampo/changesets/gemini-content-filter-errors.md new file mode 100644 index 000000000..4fb2fd86b --- /dev/null +++ b/.sampo/changesets/gemini-content-filter-errors.md @@ -0,0 +1,5 @@ +--- +pypi/posthog: patch +--- + +Capture Gemini generations that the content filters blocked (a blocked prompt, or a response stopped with a filter finish reason such as `PROHIBITED_CONTENT`) with `$ai_is_error` and an `$ai_error` that names the reason. diff --git a/posthog/ai/gemini/gemini_converter.py b/posthog/ai/gemini/gemini_converter.py index 09ae82d25..d4103a051 100644 --- a/posthog/ai/gemini/gemini_converter.py +++ b/posthog/ai/gemini/gemini_converter.py @@ -339,6 +339,46 @@ def extract_gemini_stop_reason(response: Any) -> Optional[str]: return None +# Finish reasons that mean Gemini's content filters stopped the response. The +# request itself succeeds, so neither an exception nor the HTTP status shows it. +_GEMINI_BLOCKED_FINISH_REASONS = frozenset( + { + "SAFETY", + "RECITATION", + "BLOCKLIST", + "PROHIBITED_CONTENT", + "SPII", + "IMAGE_SAFETY", + "IMAGE_PROHIBITED_CONTENT", + "IMAGE_RECITATION", + } +) + + +def _gemini_block_reason_from_stop_reason(stop_reason: Optional[str]) -> Optional[str]: + """Extract block reason from a Gemini stop reason.""" + if stop_reason in _GEMINI_BLOCKED_FINISH_REASONS: + return f"Gemini blocked the response: {stop_reason}" + return None + + +def _extract_gemini_block_reason(response: Any) -> Optional[str]: + """ + Extract block reason from Gemini response. + + Gemini blocks either the prompt (``prompt_feedback.block_reason``, with no + candidates) or the generated response (a filter finish reason). The text + holds only the reason's name, never content, so privacy mode keeps it. + """ + prompt_feedback = getattr(response, "prompt_feedback", None) + if prompt_feedback is not None: + block_reason = getattr(prompt_feedback, "block_reason", None) + name = getattr(block_reason, "name", block_reason) + if isinstance(name, str) and name not in ("", "BLOCKED_REASON_UNSPECIFIED"): + return f"Gemini blocked the prompt: {name}" + return _gemini_block_reason_from_stop_reason(extract_gemini_stop_reason(response)) + + def extract_gemini_stop_reason_from_chunk(chunk: Any) -> Optional[str]: """Extract stop reason from a Gemini streaming chunk.""" return extract_gemini_stop_reason(chunk) diff --git a/posthog/ai/utils.py b/posthog/ai/utils.py index 54c601a3d..2e4113771 100644 --- a/posthog/ai/utils.py +++ b/posthog/ai/utils.py @@ -370,6 +370,28 @@ def extract_stop_reason(response: Any, provider: str) -> Optional[str]: return None +def _extract_block_reason(response: Any, provider: str) -> Optional[str]: + """Extract content filter block reason from response based on provider.""" + if provider == "gemini": + from posthog.ai.gemini.gemini_converter import _extract_gemini_block_reason + + return _extract_gemini_block_reason(response) + return None + + +def _extract_stream_block_reason( + stop_reason: Optional[str], provider: str +) -> Optional[str]: + """Extract content filter block reason from a stream's stop reason.""" + if provider == "gemini": + from posthog.ai.gemini.gemini_converter import ( + _gemini_block_reason_from_stop_reason, + ) + + return _gemini_block_reason_from_stop_reason(stop_reason) + return None + + def extract_available_tool_calls(provider: str, kwargs: Dict[str, Any]): """ Extract available tool calls for the given provider. @@ -602,6 +624,11 @@ def call_llm_and_track_usage( if stop_reason is not None: tag("$ai_stop_reason", stop_reason) + if error is None: + block_reason = _extract_block_reason(response, provider) + if block_reason is not None: + error_params = {"$ai_is_error": True, "$ai_error": block_reason} + if not has_person_distinct_id: tag("$process_person_profile", False) @@ -774,6 +801,11 @@ async def call_llm_and_track_usage_async( if stop_reason is not None: tag("$ai_stop_reason", stop_reason) + if error is None: + block_reason = _extract_block_reason(response, provider) + if block_reason is not None: + error_params = {"$ai_is_error": True, "$ai_error": block_reason} + if not has_person_distinct_id: tag("$process_person_profile", False) @@ -1204,6 +1236,12 @@ def capture_streaming_event( if stop_reason is not None: event_properties["$ai_stop_reason"] = stop_reason + if error is None: + block_reason = _extract_stream_block_reason(stop_reason, event_data["provider"]) + if block_reason is not None: + event_properties["$ai_is_error"] = True + event_properties["$ai_error"] = block_reason + # Handle provider-specific fields if ( event_data["provider"] == "openai" diff --git a/posthog/test/ai/gemini/test_gemini.py b/posthog/test/ai/gemini/test_gemini.py index b616dcd89..bb76bced1 100644 --- a/posthog/test/ai/gemini/test_gemini.py +++ b/posthog/test/ai/gemini/test_gemini.py @@ -1706,6 +1706,135 @@ def mock_streaming_response(): assert props["$ai_stop_reason"] == "STOP" +def _gemini_response(finish_reason=None, prompt_block_reason=None): + mock_response = MagicMock() + mock_response.text = None if finish_reason != "STOP" else "Test" + + mock_usage = MagicMock() + mock_usage.prompt_token_count = 10 + mock_usage.candidates_token_count = 0 + mock_usage.cached_content_token_count = 0 + mock_usage.thoughts_token_count = 0 + mock_usage.model_dump.return_value = {"prompt_token_count": 10} + mock_response.usage_metadata = mock_usage + + if prompt_block_reason is None: + mock_response.prompt_feedback = None + else: + mock_response.prompt_feedback = MagicMock() + mock_response.prompt_feedback.block_reason = MagicMock() + mock_response.prompt_feedback.block_reason.name = prompt_block_reason + + if finish_reason is None: + mock_response.candidates = [] + else: + mock_candidate = MagicMock() + mock_candidate.finish_reason = MagicMock() + mock_candidate.finish_reason.name = finish_reason + mock_candidate.content = MagicMock() + mock_candidate.content.parts = [] + mock_response.candidates = [mock_candidate] + return mock_response + + +@pytest.mark.parametrize( + "response_kwargs,expected_error", + [ + ( + {"finish_reason": "PROHIBITED_CONTENT"}, + "Gemini blocked the response: PROHIBITED_CONTENT", + ), + ({"finish_reason": "SAFETY"}, "Gemini blocked the response: SAFETY"), + ({"prompt_block_reason": "SAFETY"}, "Gemini blocked the prompt: SAFETY"), + ], +) +def test_content_filter_block_captured_as_error( + mock_client, mock_google_genai_client, response_kwargs, expected_error +): + mock_google_genai_client.models.generate_content.return_value = _gemini_response( + **response_kwargs + ) + + client = Client(api_key="test-key", posthog_client=mock_client) + # The call succeeds; the block shows only in the response. + client.models.generate_content( + model="gemini-2.0-flash", + contents=["Hello"], + posthog_distinct_id="test-id", + ) + + props = mock_client.capture.call_args[1]["properties"] + assert props["$ai_is_error"] is True + assert props["$ai_error"] == expected_error + assert props["$ai_http_status"] == 200 + + +@pytest.mark.parametrize("finish_reason", ["STOP", "MAX_TOKENS"]) +def test_unblocked_response_is_not_an_error( + mock_client, mock_google_genai_client, finish_reason +): + mock_google_genai_client.models.generate_content.return_value = _gemini_response( + finish_reason=finish_reason, prompt_block_reason="BLOCKED_REASON_UNSPECIFIED" + ) + + client = Client(api_key="test-key", posthog_client=mock_client) + client.models.generate_content( + model="gemini-2.0-flash", + contents=["Hello"], + posthog_distinct_id="test-id", + ) + + props = mock_client.capture.call_args[1]["properties"] + assert "$ai_is_error" not in props + assert "$ai_error" not in props + + +def test_content_filter_block_error_kept_in_privacy_mode( + mock_client, mock_google_genai_client +): + mock_client.privacy_mode = True + mock_google_genai_client.models.generate_content.return_value = _gemini_response( + finish_reason="PROHIBITED_CONTENT" + ) + + client = Client(api_key="test-key", posthog_client=mock_client) + client.models.generate_content( + model="gemini-2.0-flash", + contents=["Hello"], + posthog_distinct_id="test-id", + ) + + props = mock_client.capture.call_args[1]["properties"] + assert props["$ai_error"] == "Gemini blocked the response: PROHIBITED_CONTENT" + + +def test_content_filter_block_captured_as_error_when_streaming( + mock_client, mock_google_genai_client +): + def mock_streaming_response(): + yield _gemini_response(finish_reason="PROHIBITED_CONTENT") + + mock_google_genai_client.models.generate_content_stream.return_value = ( + mock_streaming_response() + ) + + client = Client(api_key="test-key", posthog_client=mock_client) + list( + client.models.generate_content_stream( + model="gemini-2.0-flash", + contents=["Hello"], + posthog_distinct_id="test-id", + ) + ) + + assert mock_client.capture.call_count == 1 + props = mock_client.capture.call_args[1]["properties"] + assert props["$ai_stop_reason"] == "PROHIBITED_CONTENT" + assert props["$ai_is_error"] is True + assert props["$ai_error"] == "Gemini blocked the response: PROHIBITED_CONTENT" + assert props["$ai_http_status"] == 200 + + GEMINI_API_KEY = os.getenv("GEMINI_API_KEY") diff --git a/posthog/test/ai/gemini/test_gemini_async.py b/posthog/test/ai/gemini/test_gemini_async.py index b4e63c019..3babce57c 100644 --- a/posthog/test/ai/gemini/test_gemini_async.py +++ b/posthog/test/ai/gemini/test_gemini_async.py @@ -151,6 +151,32 @@ async def test_async_client_basic_generation( assert props["$ai_latency"] > 0 +async def test_async_content_filter_block_captured_as_error( + mock_client, mock_google_genai_client +): + mock_response = MagicMock() + mock_response.text = None + mock_response.usage_metadata = None + mock_response.prompt_feedback = None + mock_candidate = MagicMock() + mock_candidate.finish_reason = MagicMock() + mock_candidate.finish_reason.name = "PROHIBITED_CONTENT" + mock_candidate.content = MagicMock() + mock_candidate.content.parts = [] + mock_response.candidates = [mock_candidate] + mock_google_genai_client.aio.models.generate_content = AsyncMock( + return_value=mock_response + ) + + client = AsyncClient(api_key="test-key", posthog_client=mock_client) + await client.models.generate_content(model="gemini-x", contents="Hello") + + props = mock_client.capture.call_args.kwargs["properties"] + assert props["$ai_is_error"] is True + assert props["$ai_error"] == "Gemini blocked the response: PROHIBITED_CONTENT" + assert props["$ai_http_status"] == 200 + + async def test_async_client_timeout_captures_error( mock_client, mock_google_genai_client ):