Skip to content

DeepTeam is a framework to red team LLMs and AI agents.

added RTTestCase

A-Vamshicfc6d3b1a764
diff --git a/a.py b/a.py
new file mode 100644
index 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 file
diff --git a/deepteam/attacks/base_attack.py b/deepteam/attacks/base_attack.py
index 6e86468e..b83979d4 100644
--- a/deepteam/attacks/base_attack.py
+++ b/deepteam/attacks/base_attack.py
@@ -3,6 +3,7 @@ from abc import ABC, abstractmethod
class BaseAttack(ABC):
weight: int = 1
+ multi_turn: bool = False
@abstractmethod
def 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.py
index 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 tqdm
from typing import Optional, Union, List, Dict
from deepeval.models import DeepEvalBaseLLM
from deepeval.metrics.utils import initialize_model
-
+import random
from deepteam.attacks import BaseAttack
from 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_attack
from deepteam.attacks.multi_turn.types import CallbackType
from deepteam.attacks.multi_turn.base_schema import NonRefusal
from 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 = True
self.category = category
self.num_turns = num_turns
self.enable_refinement = enable_refinement
self.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.py
index 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 BaseModel
from tqdm import tqdm
from uuid import uuid4
import json
-
+import random
from deepeval.models import DeepEvalBaseLLM
from deepeval.metrics.utils import initialize_model
-
+from deepteam.attacks.multi_turn.utils import enhance_attack, a_enhance_attack
from deepteam.attacks import BaseAttack
from 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 = True
self.memory = MemorySystem()
self.target_conversation_id = str(uuid4())
self.red_teaming_chat_conversation_id = str(uuid4())
self.max_rounds = max_rounds
self.max_backtracks = max_backtracks
self.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.py
index 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 tqdm
from typing import Optional, Union, List, Dict
+import random
from deepeval.models import DeepEvalBaseLLM
from 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_attack
from deepteam.attacks.multi_turn.base_schema import NonRefusal
from deepteam.attacks.multi_turn.base_template import BaseMultiTurnTemplate
from 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 = True
self.num_turns = num_turns
self.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.py
index 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 BaseModel
from tqdm import tqdm
from typing import Optional, Union, List, Dict
-
+import random
from deepeval.models import DeepEvalBaseLLM
from 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_attack
from deepteam.attacks.multi_turn.types import CallbackType
from deepteam.attacks.multi_turn.base_schema import NonRefusal
from 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 = True
self.attack_type = type if type is not None else "dialogue"
self.persona = persona
self.num_turns = num_turns
self.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 parameters
if (
@@ -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 = None
original_attack = None
for turn in reversed(turns):
if turn.role == "user":
+ current_attack = turn.content
original_attack = turn.content
break
- 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_attack
eval_flag = False
eval_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 = None
original_attack = None
for turn in reversed(turns):
if turn.role == "user":
+ current_attack = turn.content
original_attack = turn.content
break
- 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_attack
eval_flag = False
eval_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 result
def get_name(self) -> str:
- return "Sequential Jailbreak"
+ return "Sequential Jailbreak"
\ No newline at end of file
diff --git a/deepteam/attacks/multi_turn/tree_jailbreaking/tree_jailbreaking.py b/deepteam/attacks/multi_turn/tree_jailbreaking/tree_jailbreaking.py
index 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 asyncio
import time
import json
from typing import Optional, Union, List, Dict
-
+import random
from deepeval.models import DeepEvalBaseLLM
from 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_attack
from deepteam.attacks.multi_turn.types import CallbackType
from deepteam.attacks.multi_turn.base_schema import NonRefusal
from 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 = True
self.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 statement
non_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 statement
non_refusal_prompt = JailBreakingTemplate.non_refusal(
initial_attack, enhanced_attack
diff --git a/deepteam/attacks/multi_turn/utils.py b/deepteam/attacks/multi_turn/utils.py
index 2136604c..654e6530 100644
--- a/deepteam/attacks/multi_turn/utils.py
+++ b/deepteam/attacks/multi_turn/utils.py
@@ -1,5 +1,8 @@
from typing import List
from deepeval.test_case import Turn
+from deepeval.models import DeepEvalBaseLLM
+from deepteam.attacks import BaseAttack
+import inspect
def 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 file
diff --git a/deepteam/red_teamer/red_teamer.py b/deepteam/red_teamer/red_teamer.py
index 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, SimulatedAttack
from deepteam.attacks.multi_turn.types import CallbackType
from deepteam.metrics import BaseRedTeamingMetric
from 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 attacks
if (
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_cases
self._print_risk_assessment()
return self.risk_assessment
@@ -213,11 +207,11 @@ class RedTeamer:
# Generate attacks
if (
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_cases
self._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 None
and len(simulated_attack.turn_history) > 0
@@ -324,7 +314,8 @@ class RedTeamer:
break
if 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.score
red_teaming_test_case.reason = metric.reason
except:
@@ -352,7 +338,7 @@ class RedTeamer:
raise
return red_teaming_test_case
else:
- 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_case
else:
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.score
red_teaming_test_case.reason = metric.reason
except:
@@ -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 None
and len(simulated_attack.turn_history) > 0
@@ -421,7 +403,8 @@ class RedTeamer:
break
if 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.score
red_teaming_test_case.reason = metric.reason
except:
@@ -449,7 +427,7 @@ class RedTeamer:
raise
return red_teaming_test_case
else:
- 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_case
else:
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.score
red_teaming_test_case.reason = metric.reason
except:
@@ -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.py
index 8a9a71c1..c1db9ff6 100644
--- a/deepteam/red_teamer/risk_assessment.py
+++ b/deepteam/red_teamer/risk_assessment.py
@@ -7,29 +7,7 @@ from enum import Enum
from deepeval.test_case import Turn
from 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 RTTestCase
class 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 type
vulnerability_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 = 0
diff --git a/deepteam/test_case/test_case.py b/deepteam/test_case/test_case.py
index 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 dataclass
from enum import Enum
-from pydantic import model_validator
from deepeval.test_case import LLMTestCase, Turn
class RTTurn(Turn):
- role: Literal['user', 'assistant']
- content: str
-
+ pass
class RTTestCase(LLMTestCase):
- input: str
actual_output: Optional[str] = None
turns: Optional[List[RTTurn]] = None
metadata: Optional[dict] = None
+ vulnerability: Optional[str] = None
+ vulnerability_type: Enum = None
attack_method: Optional[str] = None
+ risk_category: Optional[str] = None
+ score: Optional[float] = None
+ reason: Optional[str] = None
error: 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