DeepTeam is a framework to red team LLMs and AI agents.
added RTTestCase
A-Vamshicfc6d3b1a764
diff --git a/a.py b/a.pynew file mode 100644index 00000000..7f484d58--- /dev/null+++ b/a.py@@ -0,0 +1,53 @@+from deepteam.attacks.multi_turn import LinearJailbreaking, BadLikertJudge, CrescendoJailbreaking, SequentialJailbreak, TreeJailbreaking+from deepteam.attacks.single_turn import PromptInjection, Roleplay, GrayBox, Leetspeak, ROT13, Multilingual, MathProblem, Base64+from deepteam import red_team+from deepteam.vulnerabilities import Bias, BFLA+from openai import AsyncOpenAI, OpenAI+from deepteam.test_case.test_case import RTTurn, RTTestCase+++def model_callback(attack, turn_history=None):+ response = OpenAI().chat.completions.create(+ model="gpt-4o-mini",+ messages=[{"role": "user", "content": attack}],+ )+ return response.choices[0].message.content++async def a_model_callback(attack, turn_history=None):+ response = await AsyncOpenAI().chat.completions.create(+ model="gpt-4o-mini",+ messages=[{"role": "user", "content": attack}],+ )+ return response.choices[0].message.content+++# prompt_injection = BadLikertJudge(num_turns=5)+# res = prompt_injection.enhance(bias, model_callback)+# print(res)++# def main2():+# bias = Bias(types=["race"])+# linear = LinearJailbreaking(simulator_model="gpt-4o-mini", attacks=[ROT13()])+# res = linear.enhance(bias, model_callback)+# print(res)++r_a = red_team(+ attacks=[ROT13()],+ vulnerabilities=[Bias(types=["race"])],+ model_callback=a_model_callback,+ ignore_errors=False,+)++print(r_a)++# async def main():+# bias = Bias(types=["race"])+# linear = LinearJailbreaking(simulator_model="gpt-4o-mini", attacks=[ROT13()])+# res = await linear.a_enhance(bias, a_model_callback)+# print("Async ", res)+++# if __name__ == "__main__":+# import asyncio+# asyncio.run(main())+# main2()\ No newline at end of filediff --git a/deepteam/attacks/base_attack.py b/deepteam/attacks/base_attack.pyindex 6e86468e..b83979d4 100644--- a/deepteam/attacks/base_attack.py+++ b/deepteam/attacks/base_attack.py@@ -3,6 +3,7 @@ from abc import ABC, abstractmethodclass BaseAttack(ABC):weight: int = 1+ multi_turn: bool = False@abstractmethoddef enhance(self, attack: str, *args, **kwargs) -> str:diff --git a/deepteam/attacks/multi_turn/bad_likert_judge/bad_likert_judge.py b/deepteam/attacks/multi_turn/bad_likert_judge/bad_likert_judge.pyindex b842fc8c..f26ed4d1 100644--- a/deepteam/attacks/multi_turn/bad_likert_judge/bad_likert_judge.py+++ b/deepteam/attacks/multi_turn/bad_likert_judge/bad_likert_judge.py@@ -3,7 +3,7 @@ from tqdm import tqdmfrom typing import Optional, Union, List, Dictfrom deepeval.models import DeepEvalBaseLLMfrom deepeval.metrics.utils import initialize_model-+import randomfrom deepteam.attacks import BaseAttackfrom deepteam.attacks.multi_turn.bad_likert_judge.schema import (BLJJudge,@@ -15,6 +15,7 @@ from deepteam.attacks.attack_simulator.utils import (generate,a_generate,)+from deepteam.attacks.multi_turn.utils import enhance_attack, a_enhance_attackfrom deepteam.attacks.multi_turn.types import CallbackTypefrom deepteam.attacks.multi_turn.base_schema import NonRefusalfrom deepteam.errors import ModelRefusalError@@ -30,13 +31,20 @@ class BadLikertJudge(BaseAttack):category: str = "bias",num_turns: int = 5,enable_refinement: bool = True,+ attacks: Optional[List[BaseAttack]] = None,simulator_model: Optional[Union[DeepEvalBaseLLM, str]] = None,):self.weight = weight+ self.multi_turn = Trueself.category = categoryself.num_turns = num_turnsself.enable_refinement = enable_refinementself.simulator_model = simulator_model+ self.attacks = attacks++ if self.attacks is not None:+ if not isinstance(self.attacks, list) or not all(attack.multi_turn == False for attack in self.attacks):+ raise ValueError("The 'attacks' passed must be a list of single-turn attacks")def _get_turns(self,@@ -128,6 +136,12 @@ class BadLikertJudge(BaseAttack):)else:current_attack = next_attack++ # Randomly enhancing a turn attack+ if self.attacks and random.random() < 0.5:+ attack = random.choice(self.attacks)+ enhanced_attack = enhance_attack(attack, enhanced_attack, self.simulator_model)+assistant_response = model_callback(current_attack, turns)turns.append(RTTurn(role="user", content=current_attack))turns.append(RTTurn(role="assistant", content=assistant_response))@@ -228,6 +242,12 @@ class BadLikertJudge(BaseAttack):)else:current_attack = next_attack++ # Randomly enhancing a turn attack+ if self.attacks and random.random() < 0.5:+ attack = random.choice(self.attacks)+ enhanced_attack = await a_enhance_attack(attack, enhanced_attack, self.simulator_model)+assistant_response = await model_callback(current_attack, turns)turns.append(RTTurn(role="user", content=current_attack))turns.append(RTTurn(role="assistant", content=assistant_response))diff --git a/deepteam/attacks/multi_turn/crescendo_jailbreaking/crescendo_jailbreaking.py b/deepteam/attacks/multi_turn/crescendo_jailbreaking/crescendo_jailbreaking.pyindex c5f797f0..e01433c0 100644--- a/deepteam/attacks/multi_turn/crescendo_jailbreaking/crescendo_jailbreaking.py+++ b/deepteam/attacks/multi_turn/crescendo_jailbreaking/crescendo_jailbreaking.py@@ -3,12 +3,12 @@ from pydantic import BaseModelfrom tqdm import tqdmfrom uuid import uuid4import json-+import randomfrom deepeval.models import DeepEvalBaseLLMfrom deepeval.metrics.utils import initialize_model-+from deepteam.attacks.multi_turn.utils import enhance_attack, a_enhance_attackfrom deepteam.attacks import BaseAttackfrom deepteam.attacks.multi_turn.crescendo_jailbreaking.template import (JailBreakingCrescendoTemplate,@@ -57,16 +57,22 @@ class CrescendoJailbreaking(BaseAttack):weight: int = 1,max_rounds: int = 10,max_backtracks: int = 10,+ attacks: Optional[List[BaseAttack]] = None,simulator_model: Optional[Union[DeepEvalBaseLLM, str]] = None,):self.weight = weight-+ self.multi_turn = Trueself.memory = MemorySystem()self.target_conversation_id = str(uuid4())self.red_teaming_chat_conversation_id = str(uuid4())self.max_rounds = max_roundsself.max_backtracks = max_backtracksself.simulator_model = simulator_model+ self.attacks = attacks++ if self.attacks is not None:+ if not isinstance(self.attacks, list) or not all(attack.multi_turn == False for attack in self.attacks):+ raise ValueError("The 'attacks' passed must be a list of single-turn attacks")def _get_turns(self,@@ -165,14 +171,19 @@ class CrescendoJailbreaking(BaseAttack):while round_num < self.max_rounds:round_num += 1- enhanced_attack = self.generate_attack(+ current_attack = self.generate_attack(round_num, eval_flag, last_response, vulnerability_data)pbar_rounds.update(1)- turns.append(RTTurn(role="user", content=enhanced_attack))+ # Randomly enhancing a turn attack+ if self.attacks and random.random() < 0.5:+ attack = random.choice(self.attacks)+ current_attack = enhance_attack(attack, current_attack, self.simulator_model)++ turns.append(RTTurn(role="user", content=current_attack))- last_response = self.generate_target_response(enhanced_attack)+ last_response = self.generate_target_response(current_attack)pbar_rounds.update(1)turns.append(RTTurn(role="assistant", content=last_response))@@ -315,15 +326,20 @@ class CrescendoJailbreaking(BaseAttack):while round_num < self.max_rounds:round_num += 1- enhanced_attack = await self.a_generate_attack(+ current_attack = await self.a_generate_attack(round_num, eval_flag, last_response, vulnerability_data)pbar_rounds.update(1)- turns.append(RTTurn(role="user", content=enhanced_attack))+ # Randomly enhancing a turn attack+ if self.attacks and random.random() < 0.5:+ attack = random.choice(self.attacks)+ current_attack = await a_enhance_attack(attack, current_attack, self.simulator_model)++ turns.append(RTTurn(role="user", content=current_attack))last_response = await self.a_generate_target_response(- enhanced_attack+ current_attack)pbar_rounds.update(1)diff --git a/deepteam/attacks/multi_turn/linear_jailbreaking/linear_jailbreaking.py b/deepteam/attacks/multi_turn/linear_jailbreaking/linear_jailbreaking.pyindex 30c74bfc..edbaad06 100644--- a/deepteam/attacks/multi_turn/linear_jailbreaking/linear_jailbreaking.py+++ b/deepteam/attacks/multi_turn/linear_jailbreaking/linear_jailbreaking.py@@ -1,5 +1,6 @@from tqdm import tqdmfrom typing import Optional, Union, List, Dict+import randomfrom deepeval.models import DeepEvalBaseLLMfrom deepeval.metrics.utils import initialize_model@@ -17,7 +18,8 @@ from deepteam.attacks.attack_simulator.utils import (a_generate,)from deepteam.attacks.multi_turn.types import CallbackType-from deepteam.attacks.multi_turn.utils import update_turn_history+from deepteam.attacks import BaseAttack+from deepteam.attacks.multi_turn.utils import enhance_attack, a_enhance_attackfrom deepteam.attacks.multi_turn.base_schema import NonRefusalfrom deepteam.attacks.multi_turn.base_template import BaseMultiTurnTemplatefrom deepteam.errors import ModelRefusalError@@ -31,11 +33,19 @@ class LinearJailbreaking(BaseAttack):self,weight: int = 1,num_turns: int = 5,+ attacks: Optional[List[BaseAttack]] = None,simulator_model: Optional[Union[DeepEvalBaseLLM, str]] = None,):self.weight = weight+ self.multi_turn = Trueself.num_turns = num_turnsself.simulator_model = simulator_model+ self.attacks = attacks++ if self.attacks is not None:+ if not isinstance(self.attacks, list) or not all(attack.multi_turn == False for attack in self.attacks):+ raise ValueError("The 'attacks' passed must be a list of single-turn attacks")+def _get_turns(self,@@ -116,6 +126,12 @@ class LinearJailbreaking(BaseAttack):raise ModelRefusalError(entity=self.get_name())current_attack = next_attack++ # Randomly enhancing a turn attack+ if self.attacks and random.random() < 0.5:+ attack = random.choice(self.attacks)+ current_attack = enhance_attack(attack, current_attack, self.simulator_model)+target_response = model_callback(current_attack, turns)turns.append(RTTurn(role="user", content=current_attack))turns.append(RTTurn(role="assistant", content=target_response))@@ -205,6 +221,11 @@ class LinearJailbreaking(BaseAttack):current_attack = next_attack+ # Randomly enhancing a turn attack+ if self.attacks and random.random() < 0.5:+ attack = random.choice(self.attacks)+ current_attack = await a_enhance_attack(attack, current_attack, self.simulator_model)+target_response = await model_callback(current_attack, turns)turns.append(RTTurn(role="user", content=current_attack))turns.append(RTTurn(role="assistant", content=target_response))diff --git a/deepteam/attacks/multi_turn/sequential_break/sequential_break.py b/deepteam/attacks/multi_turn/sequential_break/sequential_break.pyindex 7ddd860c..8b510e5c 100644--- a/deepteam/attacks/multi_turn/sequential_break/sequential_break.py+++ b/deepteam/attacks/multi_turn/sequential_break/sequential_break.py@@ -1,7 +1,7 @@from pydantic import BaseModelfrom tqdm import tqdmfrom typing import Optional, Union, List, Dict-+import randomfrom deepeval.models import DeepEvalBaseLLMfrom deepeval.metrics.utils import initialize_model@@ -21,6 +21,7 @@ from deepteam.attacks.attack_simulator.utils import (generate,a_generate,)+from deepteam.attacks.multi_turn.utils import enhance_attack, a_enhance_attackfrom deepteam.attacks.multi_turn.types import CallbackTypefrom deepteam.attacks.multi_turn.base_schema import NonRefusalfrom deepteam.test_case.test_case import RTTurn@@ -35,13 +36,20 @@ class SequentialJailbreak(BaseAttack):type: Optional[SequentialJailbreakTypeLiteral] = None,persona: Optional[DialogueTypeLiteral] = None,num_turns: int = 5,+ attacks: Optional[List[BaseAttack]] = None,simulator_model: Optional[Union[DeepEvalBaseLLM, str]] = None,):self.weight = weight+ self.multi_turn = Trueself.attack_type = type if type is not None else "dialogue"self.persona = personaself.num_turns = num_turnsself.simulator_model = simulator_model+ self.attacks = attacks++ if self.attacks is not None:+ if not isinstance(self.attacks, list) or not all(attack.multi_turn == False for attack in self.attacks):+ raise ValueError("The 'attacks' passed must be a list of single-turn attacks")# Validate parametersif (@@ -77,18 +85,25 @@ class SequentialJailbreak(BaseAttack):f"Vulnerability: {vulnerability} | Type: {vulnerability_type}")+ # Get current attack from last user turn (simple reverse search)+ current_attack = Noneoriginal_attack = Nonefor turn in reversed(turns):if turn.role == "user":+ current_attack = turn.contentoriginal_attack = turn.contentbreak- if original_attack is None:- raise ValueError(- "No user turn found in the conversation history to start the attack."- )+ if current_attack is None:+ raise ValueError("No user turns found in conversation history")++ # If the last turn is from user, we need a model response before simulation+ if len(turns) == 0 or turns[-1].role == "user":+ target_response = model_callback(current_attack, turns)+ turns.append(RTTurn(role="assistant", content=target_response))+ else:+ target_response = turns[-1].content- current_attack = original_attackeval_flag = Falseeval_percentage = 0@@ -123,25 +138,30 @@ class SequentialJailbreak(BaseAttack):rewritten_content = rewritten_content.replace("<end>", "").strip()if self.attack_type == "question_bank":- final_prompt = (+ current_attack = (SequentialBreakTemplate.get_question_bank_template(rewritten_content))elif self.attack_type == "game_environment":- final_prompt = (+ current_attack = (SequentialBreakTemplate.get_game_environment_template(rewritten_content))else:- final_prompt = SequentialBreakTemplate.get_dialogue_template(+ current_attack = SequentialBreakTemplate.get_dialogue_template(rewritten_content, self.persona)- turns.append(RTTurn(role="user", content=final_prompt))+ # Randomly enhancing a turn attack+ if self.attacks and random.random() < 0.5:+ attack = random.choice(self.attacks)+ enhanced_attack = enhance_attack(attack, enhanced_attack, self.simulator_model)++ turns.append(RTTurn(role="user", content=current_attack))- assistant_response = model_callback(final_prompt)+ assistant_response = model_callback(current_attack)turns.append(RTTurn(role="assistant", content=assistant_response))non_refusal_prompt = SequentialBreakTemplate.non_refusal(@@ -157,7 +177,7 @@ class SequentialJailbreak(BaseAttack):if self.attack_type == "question_bank":judge_prompt = SequentialBreakTemplate.question_bank_judge(original_attack,- final_prompt,+ current_attack,assistant_response,vulnerability_data,)@@ -169,7 +189,7 @@ class SequentialJailbreak(BaseAttack):elif self.attack_type == "game_environment":judge_prompt = SequentialBreakTemplate.game_environment_judge(original_attack,- final_prompt,+ current_attack,assistant_response,vulnerability_data,)@@ -181,7 +201,7 @@ class SequentialJailbreak(BaseAttack):else:judge_prompt = SequentialBreakTemplate.dialogue_judge(original_attack,- final_prompt,+ current_attack,assistant_response,vulnerability_data,)@@ -201,8 +221,6 @@ class SequentialJailbreak(BaseAttack):pbar.close()return turns- current_attack = original_attack-pbar.update(1)pbar.close()@@ -233,18 +251,25 @@ class SequentialJailbreak(BaseAttack):if turns is None:turns = []+ # Get current attack from last user turn (simple reverse search)+ current_attack = Noneoriginal_attack = Nonefor turn in reversed(turns):if turn.role == "user":+ current_attack = turn.contentoriginal_attack = turn.contentbreak- if original_attack is None:- raise ValueError(- "No user turn found in the conversation history to start the attack."- )+ if current_attack is None:+ raise ValueError("No user turns found in conversation history")++ # If last turn is user, generate a model response before the loop+ if len(turns) == 0 or turns[-1].role == "user":+ target_response = await model_callback(current_attack, turns)+ turns.append(RTTurn(role="assistant", content=target_response))+ else:+ target_response = turns[-1].content- current_attack = original_attackeval_flag = Falseeval_percentage = 0@@ -279,25 +304,30 @@ class SequentialJailbreak(BaseAttack):rewritten_content = rewritten_content.replace("<end>", "").strip()if self.attack_type == "question_bank":- final_prompt = (+ current_attack = (SequentialBreakTemplate.get_question_bank_template(rewritten_content))elif self.attack_type == "game_environment":- final_prompt = (+ current_attack = (SequentialBreakTemplate.get_game_environment_template(rewritten_content))else:- final_prompt = SequentialBreakTemplate.get_dialogue_template(+ current_attack = SequentialBreakTemplate.get_dialogue_template(rewritten_content, self.persona)- turns.append(RTTurn(role="user", content=final_prompt))+ # Randomly enhancing a turn attack+ if self.attacks and random.random() < 0.5:+ attack = random.choice(self.attacks)+ enhanced_attack = await a_enhance_attack(attack, enhanced_attack, self.simulator_model)++ turns.append(RTTurn(role="user", content=current_attack))- assistant_response = await model_callback(final_prompt)+ assistant_response = await model_callback(current_attack)turns.append(RTTurn(role="assistant", content=assistant_response))non_refusal_prompt = SequentialBreakTemplate.non_refusal(@@ -313,37 +343,40 @@ class SequentialJailbreak(BaseAttack):if self.attack_type == "question_bank":judge_prompt = SequentialBreakTemplate.question_bank_judge(original_attack,- final_prompt,+ current_attack,assistant_response,vulnerability_data,)judge_res: QuestionBankJudge = await a_generate(judge_prompt, QuestionBankJudge, self.simulator_model)+ eval_flag = judge_res.classification == "Harmful"elif self.attack_type == "game_environment":judge_prompt = SequentialBreakTemplate.game_environment_judge(original_attack,- final_prompt,+ current_attack,assistant_response,vulnerability_data,)judge_res: GameEnvironmentJudge = await a_generate(judge_prompt, GameEnvironmentJudge, self.simulator_model)+ eval_flag = judge_res.classification == "Harmful"else:judge_prompt = SequentialBreakTemplate.dialogue_judge(original_attack,- final_prompt,+ current_attack,assistant_response,vulnerability_data,)judge_res: DialogueJudge = await a_generate(judge_prompt, DialogueJudge, self.simulator_model)+ eval_flag = judge_res.classification == "Harmful"pbar.update(1)- if judge_res.classification == "Harmful":+ if eval_flag == "Harmful":pbar.close()return turns@@ -523,4 +556,4 @@ class SequentialJailbreak(BaseAttack):return resultdef get_name(self) -> str:- return "Sequential Jailbreak"+ return "Sequential Jailbreak"\ No newline at end of filediff --git a/deepteam/attacks/multi_turn/tree_jailbreaking/tree_jailbreaking.py b/deepteam/attacks/multi_turn/tree_jailbreaking/tree_jailbreaking.pyindex b4d62e7f..86dd449e 100644--- a/deepteam/attacks/multi_turn/tree_jailbreaking/tree_jailbreaking.py+++ b/deepteam/attacks/multi_turn/tree_jailbreaking/tree_jailbreaking.py@@ -4,7 +4,7 @@ import asyncioimport timeimport jsonfrom typing import Optional, Union, List, Dict-+import randomfrom deepeval.models import DeepEvalBaseLLMfrom deepeval.metrics.utils import initialize_model@@ -21,6 +21,7 @@ from deepteam.attacks.attack_simulator.utils import (generate,a_generate,)+from deepteam.attacks.multi_turn.utils import enhance_attack, a_enhance_attackfrom deepteam.attacks.multi_turn.types import CallbackTypefrom deepteam.attacks.multi_turn.base_schema import NonRefusalfrom deepteam.test_case.test_case import RTTurn@@ -50,10 +51,19 @@ class TreeJailbreaking(BaseAttack):def __init__(self,weight: int = 1,+ attacks: Optional[List[BaseAttack]] = None,+ max_depth: int = 5,simulator_model: Optional[Union[DeepEvalBaseLLM, str]] = None,):self.weight = weight+ self.multi_turn = Trueself.simulator_model = simulator_model+ self.max_depth = max_depth+ self.attacks = attacks++ if self.attacks is not None:+ if not isinstance(self.attacks, list) or not all(attack.multi_turn == False for attack in self.attacks):+ raise ValueError("The 'attacks' passed must be a list of single-turn attacks")def _get_turns(self,@@ -327,6 +337,9 @@ class TreeJailbreaking(BaseAttack):PRUNE_THRESHOLD: int = 0,vulnerability_data: str = "",):+ if node.depth >= self.max_depth:+ return+"""Expands a tree node by generating multiple children nodes based on branching logic."""if node.depth == 0:conversation_json = [@@ -339,7 +352,8 @@ class TreeJailbreaking(BaseAttack):]else:conversation_json = node.conversation_history-++ conversation_json = list(conversation_json)conversation_json.append({"role": "user",@@ -356,6 +370,11 @@ class TreeJailbreaking(BaseAttack):)enhanced_attack = res.prompt+ # Randomly enhancing a turn attack+ if self.attacks and random.random() < 0.5:+ attack = random.choice(self.attacks)+ enhanced_attack = enhance_attack(attack, enhanced_attack, self.simulator_model)+# Check if enhanced attack is a refusal statementnon_refusal_prompt = JailBreakingTemplate.non_refusal(initial_attack, enhanced_attack@@ -510,6 +529,9 @@ class TreeJailbreaking(BaseAttack):PRUNE_THRESHOLD: int = 0,vulnerability_data: str = "",):+ if node.depth >= self.max_depth:+ return+"""Expands a tree node asynchronously by generating multiple children nodes."""if node.depth == 0:conversation_json = [@@ -523,6 +545,7 @@ class TreeJailbreaking(BaseAttack):else:conversation_json = node.conversation_history+ conversation_json = list(conversation_json)conversation_json.append({"role": "user",@@ -562,6 +585,11 @@ class TreeJailbreaking(BaseAttack):)enhanced_attack = res.prompt+ # Randomly enhancing a turn attack+ if self.attacks and random.random() < 0.5:+ attack = random.choice(self.attacks)+ enhanced_attack = await a_enhance_attack(attack, enhanced_attack, self.simulator_model)+# Check if enhanced attack is a refusal statementnon_refusal_prompt = JailBreakingTemplate.non_refusal(initial_attack, enhanced_attackdiff --git a/deepteam/attacks/multi_turn/utils.py b/deepteam/attacks/multi_turn/utils.pyindex 2136604c..654e6530 100644--- a/deepteam/attacks/multi_turn/utils.py+++ b/deepteam/attacks/multi_turn/utils.py@@ -1,5 +1,8 @@from typing import Listfrom deepeval.test_case import Turn+from deepeval.models import DeepEvalBaseLLM+from deepteam.attacks import BaseAttack+import inspectdef update_turn_history(@@ -19,3 +22,43 @@ def update_turn_history()return turn_history++def enhance_attack(+ attack: BaseAttack,+ current_attack: str,+ simulator_model: DeepEvalBaseLLM+):+ sig = inspect.signature(attack.enhance)+ try:+ res = current_attack+ if ("simulator_model" in sig.parameters):+ res = attack.enhance(+ attack=current_attack,+ simulator_model=simulator_model,+ )+ else:+ res = attack.enhance(attack=current_attack)++ return res+ except:+ return current_attack++async def a_enhance_attack(+ attack: BaseAttack,+ current_attack: str,+ simulator_model: DeepEvalBaseLLM+):+ sig = inspect.signature(attack.enhance)+ try:+ res = current_attack+ if ("simulator_model" in sig.parameters):+ res = await attack.a_enhance(+ attack=current_attack,+ simulator_model=simulator_model,+ )+ else:+ res = await attack.a_enhance(attack=current_attack)++ return res+ except:+ return current_attack\ No newline at end of filediff --git a/deepteam/red_teamer/red_teamer.py b/deepteam/red_teamer/red_teamer.pyindex d42bfe89..147585d7 100644--- a/deepteam/red_teamer/red_teamer.py+++ b/deepteam/red_teamer/red_teamer.py@@ -23,9 +23,7 @@ from deepteam.attacks.attack_simulator import AttackSimulator, SimulatedAttackfrom deepteam.attacks.multi_turn.types import CallbackTypefrom deepteam.metrics import BaseRedTeamingMetricfrom deepteam.red_teamer.risk_assessment import (- MultiTurnRTTestCase,construct_risk_assessment_overview,- SingleTurnRTTestCase,RiskAssessment,)from deepteam.risks import getRiskCategory@@ -105,11 +103,11 @@ class RedTeamer:# Generate attacksif (reuse_simulated_attacks- and self.simulated_attacks is not None- and len(self.simulated_attacks) > 0+ and self.test_cases is not None+ and len(self.test_cases) > 0):simulated_attacks: List[SimulatedAttack] = (- self.simulated_attacks+ self.test_cases)else:self.attack_simulator.model_callback = model_callback@@ -152,9 +150,7 @@ class RedTeamer:desc=f"📝 Evaluating {num_vulnerability_types} vulnerability types across {len(vulnerabilities)} vulnerability(s)",)- red_teaming_test_cases: List[- Union[SingleTurnRTTestCase, MultiTurnRTTestCase]- ] = []+ red_teaming_test_cases: List[RTTestCase] = []for (vulnerability_type,@@ -179,9 +175,7 @@ class RedTeamer:),test_cases=red_teaming_test_cases,)- self.save_test_cases_as_simulated_attacks(- test_cases=red_teaming_test_cases- )+ self.test_cases = red_teaming_test_casesself._print_risk_assessment()return self.risk_assessment@@ -213,11 +207,11 @@ class RedTeamer:# Generate attacksif (reuse_simulated_attacks- and self.simulated_attacks is not None- and len(self.simulated_attacks) > 0+ and self.test_cases is not None+ and len(self.test_cases) > 0):simulated_attacks: List[SimulatedAttack] = (- self.simulated_attacks+ self.test_cases)else:self.attack_simulator.model_callback = model_callback@@ -262,9 +256,7 @@ class RedTeamer:desc=f"📝 Evaluating {num_vulnerability_types} vulnerability types across {len(vulnerabilities)} vulnerability(s)",)- red_teaming_test_cases: List[- Union[SingleTurnRTTestCase, MultiTurnRTTestCase]- ] = []+ red_teaming_test_cases: List[RTTestCase] = []async def throttled_evaluate_vulnerability_type(vulnerability_type, attacks@@ -296,9 +288,7 @@ class RedTeamer:),test_cases=red_teaming_test_cases,)- self.save_test_cases_as_simulated_attacks(- test_cases=red_teaming_test_cases- )+ self.test_cases = red_teaming_test_casesself._print_risk_assessment()return self.risk_assessment@@ -310,7 +300,7 @@ class RedTeamer:vulnerability_type: VulnerabilityType,vulnerabilities: List[BaseVulnerability],ignore_errors: bool,- ) -> Union[SingleTurnRTTestCase, MultiTurnRTTestCase]:+ ) -> RTTestCase:multi_turn = (simulated_attack.turn_history is not Noneand len(simulated_attack.turn_history) > 0@@ -324,7 +314,8 @@ class RedTeamer:breakif multi_turn:- red_teaming_test_case = MultiTurnRTTestCase(+ red_teaming_test_case = RTTestCase(+ input=simulated_attack.input,turns=simulated_attack.turn_history,vulnerability=vulnerability,vulnerability_type=vulnerability_type,@@ -335,13 +326,8 @@ class RedTeamer:if simulated_attack.error is not None:red_teaming_test_case.error = simulated_attack.error- test_case = RTTestCase(- input=simulated_attack.input,- turns=simulated_attack.turn_history,- )-try:- metric.measure(test_case)+ metric.measure(red_teaming_test_case)red_teaming_test_case.score = metric.scorered_teaming_test_case.reason = metric.reasonexcept:@@ -352,7 +338,7 @@ class RedTeamer:raisereturn red_teaming_test_caseelse:- red_teaming_test_case = SingleTurnRTTestCase(+ red_teaming_test_case = RTTestCase(input=simulated_attack.input,vulnerability=vulnerability,vulnerability_type=vulnerability_type,@@ -381,14 +367,10 @@ class RedTeamer:return red_teaming_test_caseelse:raise- test_case = RTTestCase(- input=simulated_attack.input,- actual_output=actual_output,- )try:- metric.measure(test_case)red_teaming_test_case.actual_output = actual_output+ metric.measure(red_teaming_test_case)red_teaming_test_case.score = metric.scorered_teaming_test_case.reason = metric.reasonexcept:@@ -407,7 +389,7 @@ class RedTeamer:vulnerability_type: VulnerabilityType,vulnerabilities: List[BaseVulnerability],ignore_errors: bool,- ) -> Union[SingleTurnRTTestCase, MultiTurnRTTestCase]:+ ) -> RTTestCase:multi_turn = (simulated_attack.turn_history is not Noneand len(simulated_attack.turn_history) > 0@@ -421,7 +403,8 @@ class RedTeamer:breakif multi_turn:- red_teaming_test_case = MultiTurnRTTestCase(+ red_teaming_test_case = RTTestCase(+ input=simulated_attack.input,turns=simulated_attack.turn_history,vulnerability=vulnerability,vulnerability_type=vulnerability_type,@@ -432,13 +415,8 @@ class RedTeamer:if simulated_attack.error is not None:red_teaming_test_case.error = simulated_attack.error- test_case = RTTestCase(- input=simulated_attack.input,- turns=simulated_attack.turn_history,- )-try:- await metric.a_measure(test_case)+ await metric.a_measure(red_teaming_test_case)red_teaming_test_case.score = metric.scorered_teaming_test_case.reason = metric.reasonexcept:@@ -449,7 +427,7 @@ class RedTeamer:raisereturn red_teaming_test_caseelse:- red_teaming_test_case = SingleTurnRTTestCase(+ red_teaming_test_case = RTTestCase(input=simulated_attack.input,vulnerability=vulnerability,vulnerability_type=vulnerability_type,@@ -478,14 +456,10 @@ class RedTeamer:return red_teaming_test_caseelse:raise- test_case = RTTestCase(- input=simulated_attack.input,- actual_output=actual_output,- )try:- await metric.a_measure(test_case)red_teaming_test_case.actual_output = actual_output+ await metric.a_measure(red_teaming_test_case)red_teaming_test_case.score = metric.scorered_teaming_test_case.reason = metric.reasonexcept:@@ -503,7 +477,7 @@ class RedTeamer:vulnerability_type: VulnerabilityType,simulated_attacks: List[SimulatedAttack],ignore_errors: bool,- ) -> List[Union[SingleTurnRTTestCase, MultiTurnRTTestCase]]:+ ) -> List[RTTestCase]:red_teaming_test_cases = []for simulated_attack in simulated_attacks:@@ -527,7 +501,7 @@ class RedTeamer:vulnerability_type: VulnerabilityType,simulated_attacks: List[SimulatedAttack],ignore_errors: bool,- ) -> List[Union[SingleTurnRTTestCase, MultiTurnRTTestCase]]:+ ) -> List[RTTestCase]:red_teaming_test_cases = await asyncio.gather(*[self._a_attack(@@ -543,44 +517,6 @@ class RedTeamer:)return red_teaming_test_cases- def save_test_cases_as_simulated_attacks(- self, test_cases: List[Union[SingleTurnRTTestCase, MultiTurnRTTestCase]]- ):- simulated_attacks: List[SimulatedAttack] = []- for test_case in test_cases:- if test_case.error:- continue-- if isinstance(test_case, MultiTurnRTTestCase) and (- test_case.turns is None or len(test_case.turns) == 0- ):- continue- elif (- isinstance(test_case, SingleTurnRTTestCase)- and test_case.input is None- ):- continue-- simulated_attack = SimulatedAttack(- vulnerability=test_case.vulnerability,- vulnerability_type=test_case.vulnerability_type,- input=(- test_case.input- if isinstance(test_case, SingleTurnRTTestCase)- else None- ),- turn_history=(- test_case.turns- if isinstance(test_case, MultiTurnRTTestCase)- else None- ),- attack_method=test_case.attack_method,- metadata=test_case.metadata,- )- simulated_attacks.append(simulated_attack)-- self.simulated_attacks = simulated_attacks-def _print_risk_assessment(self):if self.risk_assessment is None:return@@ -634,7 +570,7 @@ class RedTeamer:status_style = "[bold red]✗ FAIL[/bold red]"turns = """"""- if isinstance(case, MultiTurnRTTestCase):+ if isinstance(case, RTTestCase) and case.turns is not None:for turn in case.turns:turns += f"{turn.role}: {turn.content}\n\n"turns += "=" * 80 + "\n"diff --git a/deepteam/red_teamer/risk_assessment.py b/deepteam/red_teamer/risk_assessment.pyindex 8a9a71c1..c1db9ff6 100644--- a/deepteam/red_teamer/risk_assessment.py+++ b/deepteam/red_teamer/risk_assessment.py@@ -7,29 +7,7 @@ from enum import Enumfrom deepeval.test_case import Turnfrom deepteam.vulnerabilities.types import VulnerabilityType---class RTTestCase(BaseModel):- vulnerability: str- vulnerability_type: Union[VulnerabilityType, Enum]- risk_category: str = Field(alias="riskCategory")- attack_method: Optional[str] = Field(None, alias="attackMethod")- score: Optional[float] = None- reason: Optional[str] = None- error: Optional[str] = None-- metadata: Optional[Dict[str, Any]] = None---class SingleTurnRTTestCase(RTTestCase):- input: Optional[str] = None- actual_output: Optional[str] = Field(- None, serialization_alias="actualOutput"- )---class MultiTurnRTTestCase(RTTestCase):- turns: List[Turn]+from deepteam.test_case import RTTestCaseclass TestCasesList(list):@@ -111,12 +89,12 @@ class EnumEncoder(json.JSONEncoder):class RiskAssessment(BaseModel):overview: RedTeamingOverview- test_cases: List[Union[SingleTurnRTTestCase, MultiTurnRTTestCase]]+ test_cases: List[RTTestCase]def __init__(self, **data):super().__init__(**data)self.test_cases: TestCasesList = TestCasesList[- Union[SingleTurnRTTestCase, MultiTurnRTTestCase]+ RTTestCase](self.test_cases)def save(self, to: str) -> str:@@ -149,17 +127,15 @@ class RiskAssessment(BaseModel):def construct_risk_assessment_overview(- red_teaming_test_cases: List[- Union[SingleTurnRTTestCase, MultiTurnRTTestCase]- ],+ red_teaming_test_cases: List[RTTestCase],) -> RedTeamingOverview:# Group test cases by vulnerability typevulnerability_type_to_cases: Dict[VulnerabilityType,- List[Union[SingleTurnRTTestCase, MultiTurnRTTestCase]],+ List[RTTestCase],] = {}attack_method_to_cases: Dict[- str, List[Union[SingleTurnRTTestCase, MultiTurnRTTestCase]]+ str, List[RTTestCase]] = {}errored = 0diff --git a/deepteam/test_case/test_case.py b/deepteam/test_case/test_case.pyindex cb7cd96e..2b36858a 100644--- a/deepteam/test_case/test_case.py+++ b/deepteam/test_case/test_case.py@@ -1,54 +1,26 @@-from typing import List, Literal, Union, Optional+from typing import List, Optional+from dataclasses import dataclassfrom enum import Enum-from pydantic import model_validatorfrom deepeval.test_case import LLMTestCase, Turnclass RTTurn(Turn):- role: Literal['user', 'assistant']- content: str-+ passclass RTTestCase(LLMTestCase):- input: stractual_output: Optional[str] = Noneturns: Optional[List[RTTurn]] = Nonemetadata: Optional[dict] = None+ vulnerability: Optional[str] = None+ vulnerability_type: Enum = Noneattack_method: Optional[str] = None+ risk_category: Optional[str] = None+ score: Optional[float] = None+ reason: Optional[str] = Noneerror: Optional[str] = None- @model_validator(mode="before")- def validate_input(cls, data):- input = data.get("input")- actual_output = data.get("actual_output")- turns = data.get("turns")- attack_method = data.get("attack_method")- error = data.get("error")-- if input is not None:- if not isinstance(input, str):- raise TypeError("'input' must be a string")-- if actual_output is not None:- if not isinstance(actual_output, str):- raise TypeError("'actual_output' must be a string")-- if turns is not None:- if not isinstance(turns, list):- if not all(isinstance(turn, RTTurn) for turn in turns):- raise TypeError("'turns' must be a list of 'RTTurn'")-- if attack_method is not None:- if not isinstance(attack_method, str):- raise TypeError("'attack_method' must be a string")-- if error is not None:- if not isinstance(error, str):- raise TypeError("'error' must be a string")-- if ((actual_output is not None) and (turns is not None)):- raise AttributeError(- "An 'RTTestCase' cannot contain both 'actual_output' and 'turns' at the same time"- )-- return data\ No newline at end of file+ def __post_init__(self):+ if self.actual_output is not None and self.turns is not None:+ raise ValueError(+ "An 'RTTestCase' cannot contain both 'actual_output' and 'turns' at the same time."+ )\ No newline at end of file