MAINT FIX: Moving Message metadata to AttackResult and attack score fix

doc/api.rst

@@ -198,6 +198,7 @@ API Reference
     TAPAttack
     TAPAttackContext
     TAPAttackResult
+    TAPAttackScoringConfig
     TreeOfAttacksWithPruningAttack
 
 :py:mod:`pyrit.executor.promptgen`

pyrit/executor/attack/__init__.py

@@ -35,6 +35,7 @@
     TAPAttack,
     TAPAttackContext,
     TAPAttackResult,
+    TAPAttackScoringConfig,
     TreeOfAttacksWithPruningAttack,
     generate_simulated_conversation_async,
 )
@@ -68,6 +69,7 @@
     "TreeOfAttacksWithPruningAttack",
     "TAPAttackContext",
     "TAPAttackResult",
+    "TAPAttackScoringConfig",
     "SingleTurnAttackStrategy",
     "SingleTurnAttackContext",
     "PromptSendingAttack",

pyrit/executor/attack/component/conversation_manager.py

@@ -544,8 +544,11 @@ async def _process_prepended_for_chat_target_async(
             # Multi-part messages (e.g., text + image) may have scores on multiple pieces
             last_message = valid_messages[-1]
             if last_message.api_role == "assistant":
-                prompt_ids = [str(piece.original_prompt_id) for piece in last_message.message_pieces]
-                state.last_assistant_message_scores = list(self._memory.get_prompt_scores(prompt_ids=prompt_ids))
+                scores = []
+                for piece in last_message.message_pieces:
+                    if piece.scores:
+                        scores.extend(piece.scores)
+                state.last_assistant_message_scores = scores
 
         return state
 

pyrit/executor/attack/core/attack_strategy.py

@@ -278,6 +278,48 @@ def get_objective_target(self) -> PromptTarget:
         """
         return self._objective_target
 
+    def _get_attack_result_metadata(
+        self,
+        *,
+        context: AttackStrategyContextT,
+        request_converters: Optional[list[Any]] = None,
+    ) -> dict[str, Any]:
+        """
+        Build common metadata fields for AttackResult.
+
+        This helper method extracts metadata and consolidates it for per-attack storage.
+
+        Args:
+            context: The attack context containing memory labels and other state.
+            request_converters: Optional list of PromptConverterConfiguration objects
+                used in the attack.
+
+        Returns:
+            Dict: A dictionary containing attack_identifier, objective_target_identifier,
+                  request_converter_identifiers, and labels that can be unpacked into
+                  AttackResult constructor.
+        """
+        request_converter_identifiers = None
+        if request_converters:
+            # request_converters is a list of PromptConverterConfiguration objects
+            # Each config has a 'converters' list of actual PromptConverter instances
+            all_converters = []
+            for config in request_converters:
+                if hasattr(config, "converters"):
+                    all_converters.extend(config.converters)
+                elif hasattr(config, "get_identifier"):
+                    # Direct converter object
+                    all_converters.append(config)
+            if all_converters:
+                request_converter_identifiers = [converter.get_identifier() for converter in all_converters]
+
+        return {
+            "attack_identifier": self.get_identifier(),
+            "objective_target_identifier": self.get_objective_target().get_identifier(),
+            "request_converter_identifiers": request_converter_identifiers,
+            "labels": context.memory_labels if context.memory_labels else None,
+        }
+
     def get_attack_scoring_config(self) -> Optional[AttackScoringConfig]:
         """
         Get the attack scoring configuration used by this strategy.

pyrit/executor/attack/multi_turn/__init__.py

@@ -22,6 +22,7 @@
     TAPAttack,
     TAPAttackContext,
     TAPAttackResult,
+    TAPAttackScoringConfig,
     TreeOfAttacksWithPruningAttack,
 )
 
@@ -43,4 +44,5 @@
     "TAPAttack",
     "TAPAttackResult",
     "TAPAttackContext",
+    "TAPAttackScoringConfig",
 ]

pyrit/executor/attack/multi_turn/chunked_request.py

@@ -291,18 +291,20 @@ async def _perform_async(self, *, context: ChunkedRequestAttackContext) -> Attac
         # Determine the outcome
         outcome, outcome_reason = self._determine_attack_outcome(score=score)
 
+        # Build common metadata for the attack result
+        metadata = self._get_attack_result_metadata(context=context, request_converters=self._request_converters)
+
         # Create attack result
         return AttackResult(
             conversation_id=context.session.conversation_id,
             objective=context.objective,
-            attack_identifier=self.get_identifier(),
-            last_response=response.get_piece() if response else None,
-            last_score=score,
+            automated_objective_score=score,
             related_conversations=context.related_conversations,
             outcome=outcome,
             outcome_reason=outcome_reason,
             executed_turns=context.executed_turns,
             metadata={"combined_chunks": combined_value, "chunk_count": len(context.chunk_responses)},
+            **metadata,
         )
 
     def _determine_attack_outcome(

pyrit/executor/attack/multi_turn/crescendo.py

@@ -49,6 +49,7 @@
     SelfAskRefusalScorer,
     SelfAskScaleScorer,
 )
+from pyrit.score.score_utils import normalize_score_to_float
 
 logger = logging.getLogger(__name__)
 
@@ -64,10 +65,21 @@ class CrescendoAttackContext(MultiTurnAttackContext[Any]):
     backtrack_count: int = 0
 
 
-@dataclass
 class CrescendoAttackResult(AttackResult):
     """Result of the Crescendo attack strategy execution."""
 
+    def __init__(self, *, backtrack_count: int = 0, **kwargs: Any) -> None:
+        """
+        Initialize a CrescendoAttackResult.
+
+        Args:
+            backtrack_count: Number of backtracks performed during the attack.
+            **kwargs: All other arguments passed to AttackResult.
+        """
+        super().__init__(**kwargs)
+        # Store in metadata for database serialization
+        self.metadata["backtrack_count"] = backtrack_count
+
     @property
     def backtrack_count(self) -> int:
         """
@@ -84,7 +96,7 @@ def backtrack_count(self, value: int) -> None:
         Set the number of backtracks performed during the attack.
 
         Args:
-            value (int): The number of backtracks to set.
+            value: The number of backtracks to set.
         """
         self.metadata["backtrack_count"] = value
 
@@ -387,20 +399,21 @@ async def _perform_async(self, *, context: CrescendoAttackContext) -> CrescendoA
             else f"Max turns ({self._max_turns}) reached without achieving objective"
         )
 
+        # Build common metadata for the attack result
+        metadata = self._get_attack_result_metadata(context=context, request_converters=self._request_converters)
+
         # Prepare the result
         result = CrescendoAttackResult(
-            attack_identifier=self.get_identifier(),
             conversation_id=context.session.conversation_id,
             objective=context.objective,
             outcome=(AttackOutcome.SUCCESS if achieved_objective else AttackOutcome.FAILURE),
             outcome_reason=outcome_reason,
             executed_turns=context.executed_turns,
-            last_response=context.last_response.get_piece() if context.last_response else None,
-            last_score=context.last_score,
-            related_conversations=context.related_conversations,  # Use related_conversations here
+            automated_objective_score=context.last_score,
+            related_conversations=context.related_conversations,
+            backtrack_count=context.backtrack_count,
+            **metadata,
         )
-        # setting metadata for backtrack count
-        result.backtrack_count = context.backtrack_count
         return result
 
     async def _teardown_async(self, *, context: CrescendoAttackContext) -> None:
@@ -478,7 +491,7 @@ def _build_adversarial_prompt(
             last_message_value = context.last_response.get_value()
 
             if last_message_value:
-                score_value = context.last_score.get_value()
+                score_value = normalize_score_to_float(context.last_score)
                 prompt_parts.extend(
                     [
                         f"\nThe target responded to the last question with: {last_message_value}",

pyrit/executor/attack/multi_turn/multi_prompt_sending.py

@@ -267,16 +267,18 @@ async def _perform_async(self, *, context: MultiTurnAttackContext[Any]) -> Attac
         # Determine the outcome
         outcome, outcome_reason = self._determine_attack_outcome(response=response, score=score, context=context)
 
+        # Build common metadata for the attack result
+        metadata = self._get_attack_result_metadata(context=context, request_converters=self._request_converters)
+
         result = AttackResult(
             conversation_id=context.session.conversation_id,
             objective=context.objective,
-            attack_identifier=self.get_identifier(),
-            last_response=response.get_piece() if response else None,
-            last_score=score,
+            automated_objective_score=score,
             related_conversations=context.related_conversations,
             outcome=outcome,
             outcome_reason=outcome_reason,
             executed_turns=context.executed_turns,
+            **metadata,
         )
 
         return result

pyrit/executor/attack/multi_turn/red_teaming.py

@@ -322,15 +322,16 @@ async def _perform_async(self, *, context: MultiTurnAttackContext[Any]) -> Attac
             context.executed_turns += 1
 
         # Prepare the result
+        metadata = self._get_attack_result_metadata(context=context, request_converters=self._request_converters)
+
         return AttackResult(
-            attack_identifier=self.get_identifier(),
             conversation_id=context.session.conversation_id,
             objective=context.objective,
             outcome=(AttackOutcome.SUCCESS if achieved_objective else AttackOutcome.FAILURE),
             executed_turns=context.executed_turns,
-            last_response=context.last_response.get_piece() if context.last_response else None,
-            last_score=context.last_score,
+            automated_objective_score=context.last_score,
             related_conversations=context.related_conversations,
+            **metadata,
         )
 
     async def _teardown_async(self, *, context: MultiTurnAttackContext[Any]) -> None: