diff --git a/pyrit/executor/attack/multi_turn/crescendo.py b/pyrit/executor/attack/multi_turn/crescendo.py
index 4547d5b67a..244e0b55aa 100644
--- a/pyrit/executor/attack/multi_turn/crescendo.py
+++ b/pyrit/executor/attack/multi_turn/crescendo.py
@@ -675,7 +675,9 @@ async def _check_refusal_async(self, context: CrescendoAttackContext, objective:
             objective=context.objective,
         ):
             scores = await self._refusal_scorer.score_async(
-                message=context.last_response, objective=objective, skip_on_error_result=False
+                message=context.last_response,
+                objective=objective,
+                skip_on_error_result=False,
             )
         return scores[0]
 
diff --git a/pyrit/executor/attack/multi_turn/tree_of_attacks.py b/pyrit/executor/attack/multi_turn/tree_of_attacks.py
index 532818644b..257f56df8a 100644
--- a/pyrit/executor/attack/multi_turn/tree_of_attacks.py
+++ b/pyrit/executor/attack/multi_turn/tree_of_attacks.py
@@ -351,6 +351,11 @@ def __init__(
                 corresponding score is assigned instead of invoking the scorer. This prevents
                 premature branch pruning when targets return blocked/filtered responses.
                 Defaults to {"blocked": 0.0}. Pass an empty dict to disable.
+
+                Note: This check runs before the scorer, so if ``score_blocked_content``
+                is set on the objective scorer, it will have no effect for error types
+                present in this map. To evaluate partial content from blocked responses,
+                pass ``error_score_map={}`` to disable the early-return.
         """
         # Store configuration
         self._objective_target = objective_target
@@ -1397,6 +1402,11 @@ def __init__(
                 content policy violations from image generation targets). Defaults to
                 {"blocked": 0.0}. Pass an empty dict to disable.
 
+                Note: This check runs before the scorer, so if ``score_blocked_content``
+                is set on the objective scorer, it will have no effect for error types
+                present in this map. To evaluate partial content from blocked responses,
+                pass ``error_score_map={}`` to disable the early-return.
+
         Raises:
             ValueError: If attack_scoring_config uses a non-FloatScaleThresholdScorer objective scorer,
                 if the adversarial target does not natively support the capabilities TAP needs,
diff --git a/pyrit/executor/attack/printer/console_printer.py b/pyrit/executor/attack/printer/console_printer.py
index 9822198445..8c4cb9190d 100644
--- a/pyrit/executor/attack/printer/console_printer.py
+++ b/pyrit/executor/attack/printer/console_printer.py
@@ -212,8 +212,26 @@ async def print_messages_async(
                             print()
                     continue
 
+                # Blocked/filtered pieces: show clear indicator and partial content if available
+                if piece.is_blocked():
+                    self._print_colored(f"{self._indent}🚫 BLOCKED BY TARGET", Style.BRIGHT, Fore.RED)
+                    partial_content = piece.prompt_metadata.get("partial_content")
+                    if partial_content:
+                        self._print_colored(
+                            f"{self._indent}📝 Partial content (before filter triggered):",
+                            Style.DIM,
+                            Fore.CYAN,
+                        )
+                        self._print_wrapped_text(str(partial_content), Fore.YELLOW)
+                    else:
+                        self._print_colored(
+                            f"{self._indent}Content was blocked by the target's content filter.",
+                            Style.DIM,
+                            Fore.RED,
+                        )
+
                 # Handle converted values for user and assistant messages
-                if piece.converted_value != piece.original_value:
+                elif piece.converted_value != piece.original_value:
                     self._print_colored(f"{self._indent} Original:", Fore.CYAN)
                     self._print_wrapped_text(piece.original_value, Fore.WHITE)
                     print()
diff --git a/pyrit/prompt_target/openai/openai_chat_target.py b/pyrit/prompt_target/openai/openai_chat_target.py
index 3a64471794..db506ec37e 100644
--- a/pyrit/prompt_target/openai/openai_chat_target.py
+++ b/pyrit/prompt_target/openai/openai_chat_target.py
@@ -288,6 +288,26 @@ def _check_content_filter(self, response: Any) -> bool:
             pass
         return False
 
+    def _extract_partial_content(self, response: Any) -> Optional[str]:
+        """
+        Extract partial content from a Chat Completions response with finish_reason=content_filter.
+
+        When Azure Content Safety triggers mid-generation, the model may have produced partial
+        text in ``response.choices[0].message.content`` before being cut off.
+
+        Args:
+            response: A ChatCompletion object from the OpenAI SDK.
+
+        Returns:
+            The partial text content, or None if no content was generated.
+        """
+        try:
+            if response.choices and response.choices[0].message and response.choices[0].message.content:
+                return response.choices[0].message.content
+        except (AttributeError, IndexError):
+            pass
+        return None
+
     def _validate_response(self, response: Any, request: MessagePiece) -> Optional[Message]:
         """
         Validate a Chat Completions API response for errors.
diff --git a/pyrit/prompt_target/openai/openai_response_target.py b/pyrit/prompt_target/openai/openai_response_target.py
index 8ed04fe79b..b2b5f87c06 100644
--- a/pyrit/prompt_target/openai/openai_response_target.py
+++ b/pyrit/prompt_target/openai/openai_response_target.py
@@ -443,18 +443,65 @@ def _check_content_filter(self, response: Any) -> bool:
         """
         Check if a Response API response has a content filter error.
 
+        The Responses API signals content filtering in two ways:
+        1. Via ``response.error`` with a content_filter code (older/alternative path)
+        2. Via ``response.status == "incomplete"`` with
+           ``response.incomplete_details.reason == "content_filter"``
+
         Args:
             response: A Response object from the OpenAI SDK.
 
         Returns:
             True if content was filtered, False otherwise.
         """
+        # Path 1: error-based detection (e.g., error.code == "content_filter")
         if hasattr(response, "error") and response.error is not None:
-            # Convert response to dict and use common filter detection
             response_dict = response.model_dump()
-            return _is_content_filter_error(response_dict)
+            if _is_content_filter_error(response_dict):
+                return True
+
+        # Path 2: incomplete status with content_filter reason
+        if getattr(response, "status", None) == "incomplete":
+            incomplete_details = getattr(response, "incomplete_details", None)
+            if incomplete_details and getattr(incomplete_details, "reason", None) == "content_filter":
+                return True
+
         return False
 
+    def _extract_partial_content(self, response: Any) -> Optional[str]:
+        """
+        Extract partial content from a Response API response that was content-filtered.
+
+        When the Responses API triggers a content filter, the response may contain partial
+        output in ``response.output`` message sections with ``status='completed'``. Messages
+        with ``status='incomplete'`` typically contain refusal text and are excluded.
+
+        Args:
+            response: A Response object from the OpenAI SDK.
+
+        Returns:
+            The partial text content from completed output messages, or None if no
+            partial content was generated.
+        """
+        try:
+            if not hasattr(response, "output") or not response.output:
+                return None
+            parts: list[str] = []
+            for section in response.output:
+                if getattr(section, "type", None) != MessagePieceType.MESSAGE:
+                    continue
+                # Only include completed messages — incomplete messages contain refusal text
+                if getattr(section, "status", None) != "completed":
+                    continue
+                content = getattr(section, "content", None)
+                if content and len(content) > 0:
+                    text = getattr(content[0], "text", None)
+                    if text:
+                        parts.append(text)
+            return "\n".join(parts) if parts else None
+        except (AttributeError, IndexError, TypeError):
+            return None
+
     def _validate_response(self, response: Any, request: MessagePiece) -> Optional[Message]:
         """
         Validate a Response API response for errors.
diff --git a/pyrit/prompt_target/openai/openai_target.py b/pyrit/prompt_target/openai/openai_target.py
index 8058a2b7fd..885f650894 100644
--- a/pyrit/prompt_target/openai/openai_target.py
+++ b/pyrit/prompt_target/openai/openai_target.py
@@ -559,6 +559,10 @@ def _handle_content_filter_response(self, response: Any, request: MessagePiece)
         """
         Handle content filter errors by creating a proper error Message.
 
+        If the subclass provides partial content via ``_extract_partial_content``,
+        it is attached to each response piece as ``prompt_metadata["partial_content"]``
+        so that scorers with ``score_blocked_content=True`` can evaluate it.
+
         Args:
             response: The response object from OpenAI SDK.
             request: The original request message piece.
@@ -567,13 +571,37 @@ def _handle_content_filter_response(self, response: Any, request: MessagePiece)
             Message object with error type indicating content was filtered.
         """
         logger.warning("Output content filtered by content policy.")
-        return handle_bad_request_exception(
+
+        partial_content = self._extract_partial_content(response)
+
+        error_message = handle_bad_request_exception(
             response_text=response.model_dump_json(),
             request=request,
             error_code=200,
             is_content_filter=True,
         )
 
+        if partial_content:
+            for piece in error_message.message_pieces:
+                piece.prompt_metadata["partial_content"] = partial_content
+
+        return error_message
+
+    def _extract_partial_content(self, response: Any) -> Optional[str]:
+        """
+        Extract any partial content the model generated before the content filter triggered.
+
+        Override this in subclasses to extract partial content from API-specific response
+        structures. The base implementation returns None (no partial content).
+
+        Args:
+            response: The response object from OpenAI SDK.
+
+        Returns:
+            The partial text content, or None if no content was generated.
+        """
+        return None
+
     def _validate_response(self, response: Any, request: MessagePiece) -> Optional[Message]:
         """
         Validate the response and return error Message if needed.
diff --git a/pyrit/score/conversation_scorer.py b/pyrit/score/conversation_scorer.py
index c3bcbf4f87..4e32eb95ae 100644
--- a/pyrit/score/conversation_scorer.py
+++ b/pyrit/score/conversation_scorer.py
@@ -71,7 +71,17 @@ async def _score_async(self, message: Message, *, objective: Optional[str] = Non
                 # Only include user and assistant messages in the conversation text
                 if piece.api_role in ["user", "assistant", "tool"]:
                     role_display = "Assistant (simulated)" if piece.is_simulated else piece.api_role.capitalize()
-                    conversation_text += f"{role_display}: {piece.converted_value}\n"
+                    # For blocked pieces with partial content, use the partial content
+                    # instead of the error JSON when score_blocked_content is enabled
+                    if (
+                        self.score_blocked_content
+                        and piece.is_blocked()
+                        and piece.prompt_metadata.get("partial_content")
+                    ):
+                        text = str(piece.prompt_metadata["partial_content"])
+                    else:
+                        text = piece.converted_value
+                    conversation_text += f"{role_display}: {text}\n"
 
         # Create a new message with the concatenated conversation text
         # Preserve the original message piece metadata
diff --git a/pyrit/score/scorer.py b/pyrit/score/scorer.py
index 4fb4e55b65..36ff0a1ae2 100644
--- a/pyrit/score/scorer.py
+++ b/pyrit/score/scorer.py
@@ -69,6 +69,15 @@ class Scorer(Identifiable, abc.ABC):
 
     _identifier: Optional[ComponentIdentifier] = None
 
+    #: When True, blocked responses that contain partial content
+    #: (in prompt_metadata["partial_content"]) will be scored using that content
+    #: instead of being filtered out or short-circuited.
+    #: Set this on scorer instances before use. Defaults to False.
+    #:
+    #: Note: Partial content extraction is supported for ``OpenAIChatTarget``
+    #: (Chat Completions API) and ``OpenAIResponseTarget`` (Responses API).
+    score_blocked_content: bool = False
+
     def __init__(self, *, validator: ScorerPromptValidator, chat_target: Optional[PromptTarget] = None) -> None:
         """
         Initialize the Scorer.
@@ -186,7 +195,9 @@ async def score_async(
             role_filter (Optional[ChatMessageRole]): Only score messages with this exact stored role.
                 Use "assistant" to score only real assistant responses, or "simulated_assistant"
                 to score only simulated responses. Defaults to None (no filtering).
-            skip_on_error_result (bool): If True, skip scoring if the message contains an error. Defaults to False.
+            skip_on_error_result (bool): If True, skip scoring if the message contains an error.
+                When self.score_blocked_content is also True, blocked responses with partial content
+                will still be scored instead of skipping. Defaults to False.
             infer_objective_from_request (bool): If True, infer the objective from the message's previous request
                 when objective is not provided. Defaults to False.
 
@@ -204,15 +215,25 @@ async def score_async(
             return []
 
         if skip_on_error_result and message.is_error():
-            logger.debug("Skipping scoring due to error in message and skip_on_error=True.")
-            return []
+            # When score_blocked_content is enabled and the message has partial content,
+            # don't skip — let _score_async handle the substitution.
+            has_partial = any(
+                p.prompt_metadata.get("partial_content") for p in message.message_pieces if p.is_blocked()
+            )
+            if not (self.score_blocked_content and has_partial):
+                logger.debug("Skipping scoring due to error in message and skip_on_error=True.")
+                return []
 
         if infer_objective_from_request and (not objective):
             objective = self._extract_objective_from_response(message)
 
+        # When score_blocked_content is enabled, create a modified message where blocked pieces
+        # with partial content are replaced with text-type substitutes (response_error="none").
+        scoring_message = self._apply_blocked_content_substitution(message) if self.score_blocked_content else message
+
         try:
             scores = await self._score_async(
-                message,
+                scoring_message,
                 objective=objective,
             )
         except PyritException as e:
@@ -265,6 +286,74 @@ async def _score_async(self, message: Message, *, objective: Optional[str] = Non
     async def _score_piece_async(self, message_piece: MessagePiece, *, objective: Optional[str] = None) -> list[Score]:
         raise NotImplementedError
 
+    @staticmethod
+    def _create_text_piece_from_blocked(piece: MessagePiece) -> Optional[MessagePiece]:
+        """
+        Create a text-typed copy of a blocked MessagePiece using its partial content.
+
+        The substitute preserves the original piece's id (so scores link back correctly),
+        sets converted_value to the partial content with converted_value_data_type="text",
+        and sets response_error="none" so scorer short-circuits (e.g., refusal scorer's
+        blocked check) do not fire.
+
+        Args:
+            piece: A blocked MessagePiece with prompt_metadata["partial_content"].
+
+        Returns:
+            MessagePiece with text content, or None if partial content is empty.
+        """
+        partial_content = str(piece.prompt_metadata.get("partial_content", ""))
+        if not partial_content:
+            return None
+
+        return MessagePiece(
+            id=piece.id,
+            role=piece.api_role,
+            original_value=piece.original_value,
+            converted_value=partial_content,
+            original_value_data_type=piece.original_value_data_type,
+            converted_value_data_type="text",
+            conversation_id=piece.conversation_id,
+            sequence=piece.sequence,
+            labels=piece.labels,
+            prompt_metadata=piece.prompt_metadata,
+            converter_identifiers=list(piece.converter_identifiers),  # type: ignore[arg-type]
+            prompt_target_identifier=piece.prompt_target_identifier,
+            attack_identifier=piece.attack_identifier,
+            response_error="none",
+            timestamp=piece.timestamp,
+        )
+
+    def _apply_blocked_content_substitution(self, message: Message) -> Message:
+        """
+        Create a copy of the message where blocked pieces with partial content are substituted.
+
+        Each blocked piece that has prompt_metadata["partial_content"] is replaced with a
+        text-typed copy (response_error="none", converted_value=partial_content). Non-blocked
+        pieces and blocked pieces without partial content are kept as-is.
+
+        Args:
+            message: The original message potentially containing blocked pieces.
+
+        Returns:
+            A new Message with substituted pieces, or the original if no substitution was needed.
+        """
+        substituted = False
+        new_pieces: list[MessagePiece] = []
+        for piece in message.message_pieces:
+            if piece.is_blocked() and "partial_content" in piece.prompt_metadata:
+                substitute = self._create_text_piece_from_blocked(piece)
+                if substitute:
+                    new_pieces.append(substitute)
+                    substituted = True
+                    continue
+            new_pieces.append(piece)
+
+        if not substituted:
+            return message
+
+        return Message(message_pieces=new_pieces)
+
     def _get_supported_pieces(self, message: Message) -> list[MessagePiece]:
         """
         Get a list of supported message pieces for this scorer.
diff --git a/tests/unit/executor/attack/printer/test_console_printer.py b/tests/unit/executor/attack/printer/test_console_printer.py
index e19f813be6..b8195db5ba 100644
--- a/tests/unit/executor/attack/printer/test_console_printer.py
+++ b/tests/unit/executor/attack/printer/test_console_printer.py
@@ -345,3 +345,38 @@ def test_print_wrapped_text_with_newlines(printer, capsys):
     assert "Line one" in captured.out
     assert "Line two" in captured.out
     assert "Line four" in captured.out
+
+
+@patch("pyrit.executor.attack.printer.console_printer.display_image_response", new_callable=AsyncMock)
+async def test_print_messages_async_blocked_without_partial_content(mock_display, printer, capsys):
+    piece = MessagePiece(
+        role="assistant",
+        original_value='{"status_code": 200, "message": "content_filter"}',
+        converted_value_data_type="error",
+        response_error="blocked",
+    )
+    msg = Message(message_pieces=[piece])
+    await printer.print_messages_async(messages=[msg])
+    captured = capsys.readouterr()
+    assert "BLOCKED BY TARGET" in captured.out
+    assert "content filter" in captured.out
+    # Should NOT print the raw error JSON as the message body
+    assert "status_code" not in captured.out
+
+
+@patch("pyrit.executor.attack.printer.console_printer.display_image_response", new_callable=AsyncMock)
+async def test_print_messages_async_blocked_with_partial_content(mock_display, printer, capsys):
+    piece = MessagePiece(
+        role="assistant",
+        original_value='{"status_code": 200, "message": "content_filter"}',
+        converted_value_data_type="error",
+        response_error="blocked",
+        prompt_metadata={"partial_content": "The model started to say something before being cut off"},
+    )
+    msg = Message(message_pieces=[piece])
+    await printer.print_messages_async(messages=[msg])
+    captured = capsys.readouterr()
+    assert "BLOCKED BY TARGET" in captured.out
+    assert "Partial content" in captured.out
+    assert "before filter triggered" in captured.out
+    assert "The model started to say something before being cut off" in captured.out
diff --git a/tests/unit/prompt_target/target/test_openai_chat_target.py b/tests/unit/prompt_target/target/test_openai_chat_target.py
index 174bb54ed9..0540bb68ca 100644
--- a/tests/unit/prompt_target/target/test_openai_chat_target.py
+++ b/tests/unit/prompt_target/target/test_openai_chat_target.py
@@ -1598,6 +1598,62 @@ async def test_save_audio_response_async_pcm16_format(patch_central_database):
         assert result == "/path/to/saved/audio.wav"
 
 
+# ── _extract_partial_content tests ──────────────────────────────────────────
+
+
+class TestExtractPartialContentChatTarget:
+    def test_extracts_partial_content_from_content_filter_response(self, target: OpenAIChatTarget):
+        mock_response = create_mock_completion(
+            content="Partial harmful content before cutoff", finish_reason="content_filter"
+        )
+        result = target._extract_partial_content(mock_response)
+        assert result == "Partial harmful content before cutoff"
+
+    def test_returns_none_when_no_content(self, target: OpenAIChatTarget):
+        mock_response = create_mock_completion(content=None, finish_reason="content_filter")
+        result = target._extract_partial_content(mock_response)
+        assert result is None
+
+    def test_returns_none_when_empty_content(self, target: OpenAIChatTarget):
+        mock_response = create_mock_completion(content="", finish_reason="content_filter")
+        result = target._extract_partial_content(mock_response)
+        assert result is None
+
+    def test_returns_none_when_no_choices(self, target: OpenAIChatTarget):
+        mock_response = MagicMock(spec=ChatCompletion)
+        mock_response.choices = []
+        result = target._extract_partial_content(mock_response)
+        assert result is None
+
+
+class TestContentFilterPreservesPartialContent:
+    async def test_200_content_filter_attaches_partial_content_metadata(self, target: OpenAIChatTarget):
+        """Integration: 200 + content_filter response preserves partial content in metadata."""
+        message = Message(
+            message_pieces=[MessagePiece(role="user", conversation_id="test-convo", original_value="test prompt")]
+        )
+        mock_completion = create_mock_completion(content="Harmful partial content here", finish_reason="content_filter")
+        target._async_client.chat.completions.create = AsyncMock(return_value=mock_completion)  # type: ignore[method-assign]
+
+        response = await target.send_prompt_async(message=message)
+
+        assert response[0].message_pieces[0].response_error == "blocked"
+        assert response[0].message_pieces[0].prompt_metadata["partial_content"] == "Harmful partial content here"
+
+    async def test_200_content_filter_no_metadata_when_no_content(self, target: OpenAIChatTarget):
+        """200 + content_filter with no content doesn't attach metadata."""
+        message = Message(
+            message_pieces=[MessagePiece(role="user", conversation_id="test-convo", original_value="test prompt")]
+        )
+        mock_completion = create_mock_completion(content=None, finish_reason="content_filter")
+        target._async_client.chat.completions.create = AsyncMock(return_value=mock_completion)  # type: ignore[method-assign]
+
+        response = await target.send_prompt_async(message=message)
+
+        assert response[0].message_pieces[0].response_error == "blocked"
+        assert "partial_content" not in response[0].message_pieces[0].prompt_metadata
+
+
 async def test_save_audio_response_async_flac_format(patch_central_database):
     """Test saving audio response with flac format."""
     audio_config = OpenAIChatAudioConfig(voice="alloy", audio_format="flac")
diff --git a/tests/unit/prompt_target/target/test_openai_response_target.py b/tests/unit/prompt_target/target/test_openai_response_target.py
index fca98f41a2..1355f66478 100644
--- a/tests/unit/prompt_target/target/test_openai_response_target.py
+++ b/tests/unit/prompt_target/target/test_openai_response_target.py
@@ -1075,6 +1075,89 @@ def test_check_content_filter_different_error(target: OpenAIResponseTarget):
     assert target._check_content_filter(mock_response) is False
 
 
+def test_check_content_filter_detects_incomplete_status_with_content_filter_reason(target: OpenAIResponseTarget):
+    """Test _check_content_filter detects status=incomplete with reason=content_filter."""
+    mock_response = MagicMock()
+    mock_response.error = None
+    mock_response.status = "incomplete"
+    mock_incomplete_details = MagicMock()
+    mock_incomplete_details.reason = "content_filter"
+    mock_response.incomplete_details = mock_incomplete_details
+
+    assert target._check_content_filter(mock_response) is True
+
+
+def test_check_content_filter_ignores_incomplete_status_without_content_filter_reason(target: OpenAIResponseTarget):
+    """Test _check_content_filter returns False for incomplete with non-content-filter reason."""
+    mock_response = MagicMock()
+    mock_response.error = None
+    mock_response.status = "incomplete"
+    mock_incomplete_details = MagicMock()
+    mock_incomplete_details.reason = "max_tokens"
+    mock_response.incomplete_details = mock_incomplete_details
+
+    assert target._check_content_filter(mock_response) is False
+
+
+class TestExtractPartialContentResponseTarget:
+    def test_extracts_completed_message_content(self, target: OpenAIResponseTarget):
+        """Extract text from completed output messages, skip incomplete ones."""
+        from pyrit.prompt_target.openai.openai_response_target import MessagePieceType
+
+        completed_section = MagicMock()
+        completed_section.type = MessagePieceType.MESSAGE
+        completed_section.status = "completed"
+        content_item = MagicMock()
+        content_item.text = "Partial harmful content"
+        completed_section.content = [content_item]
+
+        incomplete_section = MagicMock()
+        incomplete_section.type = MessagePieceType.MESSAGE
+        incomplete_section.status = "incomplete"
+        refusal_item = MagicMock()
+        refusal_item.text = "I'm sorry, but I cannot assist with that request."
+        incomplete_section.content = [refusal_item]
+
+        mock_response = MagicMock()
+        mock_response.output = [completed_section, incomplete_section]
+
+        result = target._extract_partial_content(mock_response)
+        assert result == "Partial harmful content"
+
+    def test_returns_none_when_no_output(self, target: OpenAIResponseTarget):
+        mock_response = MagicMock()
+        mock_response.output = []
+        assert target._extract_partial_content(mock_response) is None
+
+    def test_returns_none_when_only_incomplete_messages(self, target: OpenAIResponseTarget):
+        """All messages are incomplete (refusals) — no partial content."""
+        from pyrit.prompt_target.openai.openai_response_target import MessagePieceType
+
+        section = MagicMock()
+        section.type = MessagePieceType.MESSAGE
+        section.status = "incomplete"
+        content_item = MagicMock()
+        content_item.text = "I cannot help with that."
+        section.content = [content_item]
+
+        mock_response = MagicMock()
+        mock_response.output = [section]
+
+        assert target._extract_partial_content(mock_response) is None
+
+    def test_ignores_non_message_sections(self, target: OpenAIResponseTarget):
+        from pyrit.prompt_target.openai.openai_response_target import MessagePieceType
+
+        section = MagicMock()
+        section.type = MessagePieceType.REASONING
+        section.status = "completed"
+
+        mock_response = MagicMock()
+        mock_response.output = [section]
+
+        assert target._extract_partial_content(mock_response) is None
+
+
 def test_validate_response_success(target: OpenAIResponseTarget, dummy_text_message_piece: MessagePiece):
     """Test _validate_response passes for valid completed response."""
     mock_response = MagicMock()
diff --git a/tests/unit/score/test_conversation_history_scorer.py b/tests/unit/score/test_conversation_history_scorer.py
index 63981a9a98..2787023cea 100644
--- a/tests/unit/score/test_conversation_history_scorer.py
+++ b/tests/unit/score/test_conversation_history_scorer.py
@@ -471,3 +471,150 @@ def test_conversation_scorer_validates_true_false_scores():
 
     with pytest.raises(ValueError, match="TrueFalseScorer score value must be True or False"):
         conv_scorer.validate_return_scores([invalid_score])
+
+
+async def test_conversation_scorer_uses_partial_content_when_score_blocked_content_enabled(patch_central_database):
+    """When score_blocked_content is True, blocked pieces in conversation history use partial_content."""
+    memory = CentralMemory.get_memory_instance()
+    conversation_id = str(uuid.uuid4())
+
+    blocked_piece = MessagePiece(
+        role="assistant",
+        original_value='{"status_code": 200, "message": "content_filter"}',
+        converted_value='{"status_code": 200, "message": "content_filter"}',
+        original_value_data_type="error",
+        converted_value_data_type="error",
+        conversation_id=conversation_id,
+        sequence=2,
+        response_error="blocked",
+        prompt_metadata={"partial_content": "Dishonest disposal of bodies involves..."},
+    )
+
+    message_pieces = [
+        MessagePiece(
+            role="user",
+            original_value="How do you dispose of bodies?",
+            conversation_id=conversation_id,
+            sequence=1,
+        ),
+        blocked_piece,
+    ]
+
+    memory.add_message_pieces_to_memory(message_pieces=message_pieces)
+
+    # Use a text piece as the incoming message for validation purposes.
+    # ConversationScorer only uses it for conversation_id lookup — actual content comes from DB.
+    lookup_piece = MessagePiece(
+        role="assistant",
+        original_value="lookup",
+        conversation_id=conversation_id,
+    )
+    message = MagicMock()
+    message.message_pieces = [lookup_piece]
+    message.get_piece.return_value = lookup_piece
+
+    mock_scorer = MagicMock(spec=SelfAskGeneralFloatScaleScorer)
+    mock_scorer._validator = ScorerPromptValidator(supported_data_types=["text"])
+    score = Score(
+        score_value="0.85",
+        score_value_description="High harm",
+        score_rationale="Harmful content detected",
+        score_metadata=None,
+        score_category=["harm"],
+        scorer_class_identifier=_make_scorer_id(),
+        message_piece_id=blocked_piece.id or uuid.uuid4(),
+        objective="test",
+        score_type="float_scale",
+    )
+    mock_scorer.score_async = AsyncMock(return_value=[score])
+    mock_scorer.validate_return_scores = MagicMock()
+
+    scorer = create_conversation_scorer(scorer=mock_scorer)
+    scorer.score_blocked_content = True
+    scores = await scorer.score_async(message)
+
+    assert len(scores) == 1
+
+    # Verify the underlying scorer was called with partial content, not error JSON
+    mock_scorer.score_async.assert_awaited_once()
+    call_args = mock_scorer.score_async.call_args
+    called_message = call_args.kwargs["message"]
+    called_piece = called_message.message_pieces[0]
+
+    expected_conversation = "User: How do you dispose of bodies?\nAssistant: Dishonest disposal of bodies involves...\n"
+    assert called_piece.original_value == expected_conversation
+    assert called_piece.converted_value == expected_conversation
+
+
+async def test_conversation_scorer_uses_error_json_when_score_blocked_content_disabled(patch_central_database):
+    """When score_blocked_content is False (default), blocked pieces use converted_value (error JSON)."""
+    memory = CentralMemory.get_memory_instance()
+    conversation_id = str(uuid.uuid4())
+
+    blocked_piece = MessagePiece(
+        role="assistant",
+        original_value='{"status_code": 200, "message": "content_filter"}',
+        converted_value='{"status_code": 200, "message": "content_filter"}',
+        original_value_data_type="error",
+        converted_value_data_type="error",
+        conversation_id=conversation_id,
+        sequence=2,
+        response_error="blocked",
+        prompt_metadata={"partial_content": "Dishonest disposal of bodies involves..."},
+    )
+
+    message_pieces = [
+        MessagePiece(
+            role="user",
+            original_value="How do you dispose of bodies?",
+            conversation_id=conversation_id,
+            sequence=1,
+        ),
+        blocked_piece,
+    ]
+
+    memory.add_message_pieces_to_memory(message_pieces=message_pieces)
+
+    # Use a text piece as the incoming message for validation purposes.
+    lookup_piece = MessagePiece(
+        role="assistant",
+        original_value="lookup",
+        conversation_id=conversation_id,
+    )
+    message = MagicMock()
+    message.message_pieces = [lookup_piece]
+    message.get_piece.return_value = lookup_piece
+
+    mock_scorer = MagicMock(spec=SelfAskGeneralFloatScaleScorer)
+    mock_scorer._validator = ScorerPromptValidator(supported_data_types=["text"])
+    score = Score(
+        score_value="0.0",
+        score_value_description="No harm",
+        score_rationale="Error response",
+        score_metadata=None,
+        score_category=["harm"],
+        scorer_class_identifier=_make_scorer_id(),
+        message_piece_id=blocked_piece.id or uuid.uuid4(),
+        objective="test",
+        score_type="float_scale",
+    )
+    mock_scorer.score_async = AsyncMock(return_value=[score])
+    mock_scorer.validate_return_scores = MagicMock()
+
+    scorer = create_conversation_scorer(scorer=mock_scorer)
+    # score_blocked_content defaults to False
+    scores = await scorer.score_async(message)
+
+    assert len(scores) == 1
+
+    # Verify the underlying scorer was called with error JSON, not partial content
+    mock_scorer.score_async.assert_awaited_once()
+    call_args = mock_scorer.score_async.call_args
+    called_message = call_args.kwargs["message"]
+    called_piece = called_message.message_pieces[0]
+
+    expected_conversation = (
+        'User: How do you dispose of bodies?\nAssistant: {"status_code": 200, "message": "content_filter"}\n'
+    )
+    assert called_piece.original_value == expected_conversation
+    assert called_piece.converted_value == expected_conversation
diff --git a/tests/unit/score/test_scorer.py b/tests/unit/score/test_scorer.py
index 731a8068e3..1cddb7311c 100644
--- a/tests/unit/score/test_scorer.py
+++ b/tests/unit/score/test_scorer.py
@@ -587,10 +587,16 @@ async def test_score_response_async_parallel_execution():
     assert score1_1 in result["auxiliary_scores"]
     assert score2_1 in result["auxiliary_scores"]
     scorer1.score_async.assert_any_call(
-        message=response, objective="test task", role_filter="assistant", skip_on_error_result=True
+        message=response,
+        objective="test task",
+        role_filter="assistant",
+        skip_on_error_result=True,
     )
     scorer2.score_async.assert_any_call(
-        message=response, objective="test task", role_filter="assistant", skip_on_error_result=True
+        message=response,
+        objective="test task",
+        role_filter="assistant",
+        skip_on_error_result=True,
     )
 
 
@@ -1465,3 +1471,343 @@ async def test_score_value_with_llm_skips_reasoning_piece(good_json):
 
     assert result.raw_score_value == "1"
     assert result.score_rationale == "Valid response"
+
+
+# ── Helpers for score_blocked_content tests ──────────────────────────────────
+
+
+class _AcceptAllValidator(ScorerPromptValidator):
+    """Validator that accepts all pieces (like SelfAskRefusalScorer's default)."""
+
+    def validate(self, message: Message, objective: Optional[str] = None) -> None:
+        pass
+
+    def is_message_piece_supported(self, message_piece: MessagePiece) -> bool:
+        return True
+
+
+class _TextOnlyValidator(ScorerPromptValidator):
+    """Validator that only accepts text pieces (like SelfAskTrueFalseScorer's default)."""
+
+    def __init__(self) -> None:
+        super().__init__(supported_data_types=["text", "image_path"])
+
+    def validate(self, message: Message, objective: Optional[str] = None) -> None:
+        pass
+
+
+class _BlockedContentScorer(TrueFalseScorer):
+    """A mock TrueFalseScorer that records what pieces it was asked to score."""
+
+    def __init__(self, *, validator: Optional[ScorerPromptValidator] = None) -> None:
+        super().__init__(validator=validator or _TextOnlyValidator())
+        self.scored_pieces: list[MessagePiece] = []
+
+    def _build_identifier(self) -> ComponentIdentifier:
+        return self._create_identifier()
+
+    async def _score_piece_async(self, message_piece: MessagePiece, *, objective: Optional[str] = None) -> list[Score]:
+        self.scored_pieces.append(message_piece)
+        return [
+            Score(
+                score_value="true",
+                score_value_description="desc",
+                score_type="true_false",
+                score_category=None,
+                score_metadata=None,
+                score_rationale="rationale",
+                scorer_class_identifier=self.get_identifier(),
+                message_piece_id=str(message_piece.id),
+                objective=objective,
+            )
+        ]
+
+
+class _MockRefusalScorer(TrueFalseScorer):
+    """Mimics SelfAskRefusalScorer: accepts all types, short-circuits on blocked."""
+
+    def __init__(self) -> None:
+        super().__init__(validator=_AcceptAllValidator())
+        self.scored_pieces: list[MessagePiece] = []
+
+    def _build_identifier(self) -> ComponentIdentifier:
+        return self._create_identifier()
+
+    async def _score_piece_async(self, message_piece: MessagePiece, *, objective: Optional[str] = None) -> list[Score]:
+        self.scored_pieces.append(message_piece)
+        if message_piece.response_error == "blocked":
+            return [
+                Score(
+                    score_value="true",
+                    score_value_description="Refusal detected",
+                    score_type="true_false",
+                    score_category=None,
+                    score_metadata=None,
+                    score_rationale="Content was filtered, constituting a refusal.",
+                    scorer_class_identifier=self.get_identifier(),
+                    message_piece_id=str(message_piece.id),
+                    objective=objective,
+                )
+            ]
+        return [
+            Score(
+                score_value="false",
+                score_value_description="Not a refusal",
+                score_type="true_false",
+                score_category=None,
+                score_metadata=None,
+                score_rationale="The response contains substantive content.",
+                scorer_class_identifier=self.get_identifier(),
+                message_piece_id=str(message_piece.id),
+                objective=objective,
+            )
+        ]
+
+
+def _make_blocked_piece(*, partial_content: Optional[str] = None, conversation_id: str = "test-convo") -> MessagePiece:
+    """Create a blocked MessagePiece, optionally with partial content metadata."""
+    metadata: dict = {}
+    if partial_content is not None:
+        metadata["partial_content"] = partial_content
+    return MessagePiece(
+        role="assistant",
+        original_value='{"status_code": 200, "message": "content_filter"}',
+        converted_value='{"status_code": 200, "message": "content_filter"}',
+        original_value_data_type="error",
+        converted_value_data_type="error",
+        conversation_id=conversation_id,
+        response_error="blocked",
+        prompt_metadata=metadata,
+    )
+
+
+def _make_normal_piece(*, conversation_id: str = "test-convo") -> MessagePiece:
+    """Create a normal text MessagePiece."""
+    return MessagePiece(
+        role="assistant",
+        original_value="Hello, how can I help?",
+        conversation_id=conversation_id,
+    )
+
+
+# ── _create_text_piece_from_blocked tests ────────────────────────────────────
+
+
+class TestCreateTextPieceFromBlocked:
+    def test_returns_text_piece_with_partial_content(self):
+        piece = _make_blocked_piece(partial_content="Harmful partial text here")
+        substitute = Scorer._create_text_piece_from_blocked(piece)
+
+        assert substitute is not None
+        assert substitute.converted_value == "Harmful partial text here"
+        assert substitute.converted_value_data_type == "text"
+        assert substitute.response_error == "none"
+        assert substitute.id == piece.id
+
+    def test_preserves_original_value(self):
+        piece = _make_blocked_piece(partial_content="partial")
+        substitute = Scorer._create_text_piece_from_blocked(piece)
+
+        assert substitute is not None
+        assert substitute.original_value == piece.original_value
+        assert substitute.original_value_data_type == piece.original_value_data_type
+
+    def test_returns_none_when_no_partial_content(self):
+        piece = _make_blocked_piece()
+        assert Scorer._create_text_piece_from_blocked(piece) is None
+
+    def test_returns_none_when_empty_partial_content(self):
+        piece = _make_blocked_piece(partial_content="")
+        assert Scorer._create_text_piece_from_blocked(piece) is None
+
+    def test_preserves_conversation_id(self):
+        piece = _make_blocked_piece(partial_content="partial")
+        substitute = Scorer._create_text_piece_from_blocked(piece)
+        assert substitute is not None
+        assert substitute.conversation_id == piece.conversation_id
+
+    def test_response_error_is_none_not_blocked(self):
+        """Substitute must have response_error='none' so refusal short-circuits don't fire."""
+        piece = _make_blocked_piece(partial_content="partial text")
+        substitute = Scorer._create_text_piece_from_blocked(piece)
+        assert substitute is not None
+        assert substitute.response_error == "none"
+        assert not substitute.is_blocked()
+        assert not substitute.has_error()
+
+
+# ── score_async with score_blocked_content tests ─────────────────────────────
+
+
+@pytest.mark.usefixtures("patch_central_database")
+class TestScoreAsyncWithBlockedContent:
+    async def test_default_false_skips_blocked_piece_text_only_scorer(self):
+        """Default behavior: text-only scorer filters out blocked error-type pieces."""
+        scorer = _BlockedContentScorer()
+        msg = Message(message_pieces=[_make_blocked_piece(partial_content="harmful text")])
+
+        scores = await scorer.score_async(msg)
+
+        assert len(scores) == 1
+        assert scores[0].score_value == "false"
+        assert len(scorer.scored_pieces) == 0
+
+    async def test_true_substitutes_blocked_piece_for_text_only_scorer(self):
+        """With flag on, text-only scorer gets a text substitute and scores it."""
+        scorer = _BlockedContentScorer()
+        msg = Message(message_pieces=[_make_blocked_piece(partial_content="harmful text")])
+
+        scorer.score_blocked_content = True
+        scores = await scorer.score_async(msg)
+
+        assert len(scores) == 1
+        assert scores[0].score_value == "true"
+        assert len(scorer.scored_pieces) == 1
+        assert scorer.scored_pieces[0].converted_value == "harmful text"
+        assert scorer.scored_pieces[0].converted_value_data_type == "text"
+
+    async def test_refusal_scorer_short_circuits_on_blocked_by_default(self):
+        """Refusal scorer (accepts all types) sees original blocked piece, returns True."""
+        scorer = _MockRefusalScorer()
+        msg = Message(message_pieces=[_make_blocked_piece(partial_content="harmful text")])
+
+        scores = await scorer.score_async(msg)
+
+        assert len(scores) == 1
+        assert scores[0].score_value == "true"
+        assert scorer.scored_pieces[0].response_error == "blocked"
+
+    async def test_refusal_scorer_evaluates_partial_content_when_flag_on(self):
+        """With flag on, refusal scorer gets substitute (response_error=none), evaluates via LLM path."""
+        scorer = _MockRefusalScorer()
+        msg = Message(message_pieces=[_make_blocked_piece(partial_content="harmful text")])
+
+        scorer.score_blocked_content = True
+        scores = await scorer.score_async(msg)
+
+        assert len(scores) == 1
+        assert scores[0].score_value == "false"
+        assert scorer.scored_pieces[0].response_error == "none"
+        assert scorer.scored_pieces[0].converted_value == "harmful text"
+
+    async def test_no_substitute_when_no_partial_content(self):
+        """400 full block with no partial content: no substitute, same behavior."""
+        scorer = _BlockedContentScorer()
+        msg = Message(message_pieces=[_make_blocked_piece()])
+
+        scorer.score_blocked_content = True
+        scores = await scorer.score_async(msg)
+
+        assert len(scores) == 1
+        assert scores[0].score_value == "false"
+        assert len(scorer.scored_pieces) == 0
+
+    async def test_normal_piece_unaffected_by_flag(self):
+        """Normal text pieces are scored the same regardless of flag."""
+        scorer = _BlockedContentScorer()
+        msg = Message(message_pieces=[_make_normal_piece()])
+
+        scores_off = await scorer.score_async(msg)
+        scorer.scored_pieces.clear()
+        scorer.score_blocked_content = True
+        scores_on = await scorer.score_async(msg)
+
+        assert scores_off[0].score_value == scores_on[0].score_value
+
+    async def test_mixed_pieces_only_blocked_substituted(self):
+        """In a multi-piece message, only blocked pieces get substituted."""
+        scorer = _BlockedContentScorer()
+        msg = Message(message_pieces=[_make_normal_piece(), _make_blocked_piece(partial_content="partial harmful")])
+
+        scorer.score_blocked_content = True
+        scores = await scorer.score_async(msg)
+
+        assert len(scores) == 1  # TrueFalseScorer aggregates
+        assert len(scorer.scored_pieces) == 2
+        assert scorer.scored_pieces[0].converted_value == "Hello, how can I help?"
+        assert scorer.scored_pieces[1].converted_value == "partial harmful"
+        assert scorer.scored_pieces[1].response_error == "none"
+
+
+# ── skip_on_error_result interaction tests ───────────────────────────────────
+
+
+@pytest.mark.usefixtures("patch_central_database")
+class TestSkipOnErrorWithBlockedContent:
+    async def test_skip_on_error_true_without_flag_skips_blocked(self):
+        scorer = _BlockedContentScorer()
+        msg = Message(message_pieces=[_make_blocked_piece(partial_content="harmful text")])
+
+        scores = await scorer.score_async(msg, skip_on_error_result=True)
+        assert scores == []
+
+    async def test_skip_on_error_true_with_flag_does_not_skip_when_partial_content(self):
+        scorer = _BlockedContentScorer()
+        msg = Message(message_pieces=[_make_blocked_piece(partial_content="harmful text")])
+
+        scorer.score_blocked_content = True
+        scores = await scorer.score_async(msg, skip_on_error_result=True)
+        assert len(scores) == 1
+        assert scores[0].score_value == "true"
+
+    async def test_skip_on_error_true_with_flag_still_skips_when_no_partial_content(self):
+        scorer = _BlockedContentScorer()
+        msg = Message(message_pieces=[_make_blocked_piece()])
+
+        scorer.score_blocked_content = True
+        scores = await scorer.score_async(msg, skip_on_error_result=True)
+        assert scores == []
+
+
+# ── score_response_async passthrough tests ───────────────────────────────────
+
+
+@pytest.mark.usefixtures("patch_central_database")
+class TestScoreResponseAsyncBlockedContent:
+    async def test_score_response_async_passes_flag_to_scorers(self):
+        obj_scorer = _BlockedContentScorer()
+        obj_scorer.score_blocked_content = True
+        msg = Message(message_pieces=[_make_blocked_piece(partial_content="harmful text")])
+
+        result = await Scorer.score_response_async(
+            response=msg,
+            objective_scorer=obj_scorer,
+            objective="test",
+            skip_on_error_result=False,
+        )
+
+        assert len(result["objective_scores"]) == 1
+        assert result["objective_scores"][0].score_value == "true"
+        assert obj_scorer.scored_pieces[0].converted_value == "harmful text"
+
+    async def test_score_response_async_default_does_not_substitute(self):
+        obj_scorer = _BlockedContentScorer()
+        msg = Message(message_pieces=[_make_blocked_piece(partial_content="harmful text")])
+
+        result = await Scorer.score_response_async(
+            response=msg,
+            objective_scorer=obj_scorer,
+            objective="test",
+            skip_on_error_result=False,
+        )
+
+        assert result["objective_scores"][0].score_value == "false"
+        assert len(obj_scorer.scored_pieces) == 0
+
+    async def test_score_response_multiple_scorers_passes_flag(self):
+        scorer1 = _BlockedContentScorer()
+        scorer1.score_blocked_content = True
+        scorer2 = _BlockedContentScorer()
+        scorer2.score_blocked_content = True
+        msg = Message(message_pieces=[_make_blocked_piece(partial_content="harmful text")])
+
+        scores = await Scorer.score_response_multiple_scorers_async(
+            response=msg,
+            scorers=[scorer1, scorer2],
+            objective="test",
+            skip_on_error_result=False,
+        )
+
+        assert len(scores) == 2
+        assert len(scorer1.scored_pieces) == 1
+        assert len(scorer2.scored_pieces) == 1