Skip to content

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.py
index 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 tqdm
from typing import Optional, Union, List
-
+import asyncio
from deepeval.models import DeepEvalBaseLLM
from deepeval.metrics.utils import initialize_model
-from deepeval.test_case import Turn
from deepteam.attacks import BaseAttack
from deepteam.attacks.multi_turn.linear_jailbreaking.schema import (
@@ -35,7 +34,7 @@ class LinearJailbreaking(BaseAttack):
self.weight = weight
self.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 result
def get_name(self) -> str:
return "Linear Jailbreaking"