DeepTeam is a framework to red team LLMs and AI agents.
enhance updated with vulnerability for linear jailbreaking
A-Vamshi94e6d9068425
diff --git a/deepteam/attacks/multi_turn/linear_jailbreaking/linear_jailbreaking.py b/deepteam/attacks/multi_turn/linear_jailbreaking/linear_jailbreaking.pyindex 3f31bd9f..28ae2c6e 100644--- a/deepteam/attacks/multi_turn/linear_jailbreaking/linear_jailbreaking.py+++ b/deepteam/attacks/multi_turn/linear_jailbreaking/linear_jailbreaking.py@@ -1,10 +1,9 @@from tqdm import tqdmfrom typing import Optional, Union, List-+import asynciofrom deepeval.models import DeepEvalBaseLLMfrom deepeval.metrics.utils import initialize_model-from deepeval.test_case import Turnfrom deepteam.attacks import BaseAttackfrom deepteam.attacks.multi_turn.linear_jailbreaking.schema import (@@ -35,7 +34,7 @@ class LinearJailbreaking(BaseAttack):self.weight = weightself.num_turns = num_turns- def enhance(+ def _get_turns(self,model_callback: CallbackType,turns: Optional[List[RTTurn]] = None,@@ -115,7 +114,7 @@ class LinearJailbreaking(BaseAttack):pbar.close()return turns- async def a_enhance(+ async def _a_get_turns(self,model_callback: CallbackType,turns: Optional[List[RTTurn]] = None,@@ -195,6 +194,137 @@ class LinearJailbreaking(BaseAttack):pbar.close()return turns++ def enhance(+ self,+ vulnerability: "BaseVulnerability",+ model_callback: CallbackType,+ simulator_model: Optional[Union[DeepEvalBaseLLM, str]] = None,+ turns: Optional[List[RTTurn]] = None,+ ) -> dict:+ from deepteam.red_teamer.utils import group_attacks_by_vulnerability_type+ # Simulate and group attacks+ simulated_attacks = group_attacks_by_vulnerability_type(+ vulnerability.simulate_attacks()+ )++ result = {}++ for vuln_type, attacks in simulated_attacks.items():+ for attack in attacks:+ # Defensive copy to avoid mutating external turns+ inner_turns = list(turns) if turns else []++ # Case 1: No turns, or last is user -> create assistant response+ if len(inner_turns) == 0 or inner_turns[-1].role == "user":+ inner_turns = [RTTurn(role="user", content=attack.input)]+ assistant_response = model_callback(attack.input, inner_turns)+ inner_turns.append(RTTurn(role="assistant", content=assistant_response))++ # Case 2: Last is assistant -> find preceding user+ elif inner_turns[-1].role == "assistant":+ user_turn_content = None+ for turn in reversed(inner_turns[:-1]):+ if turn.role == "user":+ user_turn_content = turn.content+ break++ if user_turn_content:+ inner_turns = [+ RTTurn(role="user", content=user_turn_content),+ RTTurn(role="assistant", content=inner_turns[-1].content),+ ]+ else:+ # Fallback if no user found+ inner_turns = [RTTurn(role="user", content=attack.input)]+ assistant_response = model_callback(attack.input, inner_turns)+ inner_turns.append(RTTurn(role="assistant", content=assistant_response))++ else:+ # Unrecognized state — fallback to default+ inner_turns = [RTTurn(role="user", content=attack.input)]+ assistant_response = model_callback(attack.input, inner_turns)+ inner_turns.append(RTTurn(role="assistant", content=assistant_response))++ # Run enhancement loop and assign full turn history+ enhanced_turns = self._get_turns(+ model_callback=model_callback,+ turns=inner_turns,+ simulator_model=simulator_model,+ )++ attack.turn_history = enhanced_turns++ result[vuln_type] = attacks++ return result++ async def a_enhance(+ self,+ vulnerability: "BaseVulnerability",+ model_callback: CallbackType,+ simulator_model: Optional[Union[DeepEvalBaseLLM, str]] = None,+ turns: Optional[List[RTTurn]] = None,+ ) -> dict:+ from deepteam.red_teamer.utils import group_attacks_by_vulnerability_type++ # Simulate and group attacks asynchronously+ simulated_attacks = await vulnerability.a_simulate_attacks()+ grouped_attacks = group_attacks_by_vulnerability_type(simulated_attacks)++ result = {}++ for vuln_type, attacks in grouped_attacks.items():+ async def enhance_attack(attack):+ # Defensive copy of base turns+ inner_turns = list(turns) if turns else []++ # Case 1: No turns or ends in user — generate assistant response+ if len(inner_turns) == 0 or inner_turns[-1].role == "user":+ inner_turns = [RTTurn(role="user", content=attack.input)]+ assistant_response = await model_callback(attack.input, inner_turns)+ inner_turns.append(RTTurn(role="assistant", content=assistant_response))++ # Case 2: Ends in assistant — rebuild last user+assistant pair+ elif inner_turns[-1].role == "assistant":+ user_turn_content = None+ for turn in reversed(inner_turns[:-1]):+ if turn.role == "user":+ user_turn_content = turn.content+ break++ if user_turn_content:+ inner_turns = [+ RTTurn(role="user", content=user_turn_content),+ RTTurn(role="assistant", content=inner_turns[-1].content),+ ]+ else:+ inner_turns = [RTTurn(role="user", content=attack.input)]+ assistant_response = await model_callback(attack.input, inner_turns)+ inner_turns.append(RTTurn(role="assistant", content=assistant_response))++ else:+ # Fallback for unexpected structure+ inner_turns = [RTTurn(role="user", content=attack.input)]+ assistant_response = await model_callback(attack.input, inner_turns)+ inner_turns.append(RTTurn(role="assistant", content=assistant_response))++ # Run async enhancement and store turn history+ attack.turn_history = await self._a_get_turns(+ model_callback=model_callback,+ turns=inner_turns,+ simulator_model=simulator_model,+ )++ return attack++ # Run all attacks in this vulnerability group concurrently+ enhanced_attacks = await asyncio.gather(+ *(enhance_attack(attack) for attack in attacks)+ )+ result[vuln_type] = enhanced_attacks++ return resultdef get_name(self) -> str:return "Linear Jailbreaking"