DeepTeam is a framework to red team LLMs and AI agents.
added assess method to all vulnerabilities
A-Vamshif4b2abe5c991
diff --git a/deepteam/vulnerabilities/agentic/excessive_agency/excessive_agency.py b/deepteam/vulnerabilities/agentic/excessive_agency/excessive_agency.pyindex 07253841..2a09c76b 100644--- a/deepteam/vulnerabilities/agentic/excessive_agency/excessive_agency.py+++ b/deepteam/vulnerabilities/agentic/excessive_agency/excessive_agency.py@@ -1,13 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.agentic.excessive_agency import (ExcessiveAgencyType,)from deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import ExcessiveAgencyMetric+from deepteam.metrics import ExcessiveAgencyMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from .template import ExcessiveAgencyTemplateExcessiveAgencyLiteral = Literal["functionality", "permissions", "autonomy"]@@ -17,9 +26,12 @@ class ExcessiveAgency(BaseVulnerability):def __init__(self,purpose: str = None,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[ExcessiveAgencyLiteral]] = [type.value for type in ExcessiveAgencyType],@@ -28,18 +40,247 @@ class ExcessiveAgency(BaseVulnerability):self.get_name(), types=types, allowed_type=ExcessiveAgencyType)self.purpose = purpose- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )+ from deepteam.risks import getRiskCategory++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[ExcessiveAgencyType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )+ from deepteam.risks import getRiskCategory++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[ExcessiveAgencyType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.attacks.attack_simulator import SimulatedAttack++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ ExcessiveAgencyTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.attacks.attack_simulator import SimulatedAttack++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ ExcessiveAgencyTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: ExcessiveAgencyType,- ):+ ) -> BaseRedTeamingMetric:return ExcessiveAgencyMetric(purpose=self.purpose,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/agentic/goal_theft/goal_theft.py b/deepteam/vulnerabilities/agentic/goal_theft/goal_theft.pyindex 46f1b882..c72a9f4c 100644--- a/deepteam/vulnerabilities/agentic/goal_theft/goal_theft.py+++ b/deepteam/vulnerabilities/agentic/goal_theft/goal_theft.py@@ -1,13 +1,23 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.agentic.goal_theft import GoalTheftTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_typesfrom deepteam.metrics.agentic.extraction_success.extraction_success import (- ExtractionSuccessMetric,+ ExtractionSuccessMetric,+ BaseRedTeamingMetric)+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from .template import GoalTheftTemplateGoalTheftLiteralType = Literal["escalating_probing", "cooperative_dialogue", "social_engineering"@@ -18,9 +28,12 @@ class GoalTheft(BaseVulnerability):def __init__(self,purpose: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[GoalTheftLiteralType]] = [type.value for type in GoalTheftType],@@ -29,18 +42,247 @@ class GoalTheft(BaseVulnerability):self.get_name(), types=types, allowed_type=GoalTheftType)self.purpose = purpose- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )+ from deepteam.risks import getRiskCategory++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[GoalTheftType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )+ from deepteam.risks import getRiskCategory++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[GoalTheftType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.attacks.attack_simulator import SimulatedAttack++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ GoalTheftTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.attacks.attack_simulator import SimulatedAttack++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ GoalTheftTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: GoalTheftType,- ):+ ) -> BaseRedTeamingMetric:return ExtractionSuccessMetric(purpose=self.purpose,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/agentic/recursive_hijacking/recursive_hijacking.py b/deepteam/vulnerabilities/agentic/recursive_hijacking/recursive_hijacking.pyindex c011a480..fa11cb3e 100644--- a/deepteam/vulnerabilities/agentic/recursive_hijacking/recursive_hijacking.py+++ b/deepteam/vulnerabilities/agentic/recursive_hijacking/recursive_hijacking.py@@ -1,6 +1,12 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.agentic.recursive_hijacking import (@@ -8,8 +14,12 @@ from deepteam.vulnerabilities.agentic.recursive_hijacking import ()from deepteam.vulnerabilities.utils import validate_vulnerability_typesfrom deepteam.metrics.agentic.subversion_success.subversion_success import (- SubversionSuccessMetric,+ SubversionSuccessMetric,+ BaseRedTeamingMetric)+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from .template import RecursiveHijackingTemplateRecursiveHijackingLiteralType = Literal["self_modifying_goals",@@ -22,9 +32,12 @@ class RecursiveHijacking(BaseVulnerability):def __init__(self,purpose: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[RecursiveHijackingLiteralType]] = [type.value for type in RecursiveHijackingType],@@ -33,18 +46,247 @@ class RecursiveHijacking(BaseVulnerability):self.get_name(), types=types, allowed_type=RecursiveHijackingType)self.purpose = purpose- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )+ from deepteam.risks import getRiskCategory++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[RecursiveHijackingType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )+ from deepteam.risks import getRiskCategory++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[RecursiveHijackingType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.attacks.attack_simulator import SimulatedAttack++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ RecursiveHijackingTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.attacks.attack_simulator import SimulatedAttack++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ RecursiveHijackingTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: RecursiveHijackingType,- ):+ ) -> BaseRedTeamingMetric:return SubversionSuccessMetric(purpose=self.purpose,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/agentic/robustness/robustness.py b/deepteam/vulnerabilities/agentic/robustness/robustness.pyindex 244eeede..9a2cd1b7 100644--- a/deepteam/vulnerabilities/agentic/robustness/robustness.py+++ b/deepteam/vulnerabilities/agentic/robustness/robustness.py@@ -1,11 +1,20 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.agentic.robustness import RobustnessTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import HijackingMetric, OverrelianceMetric+from deepteam.metrics import HijackingMetric, OverrelianceMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from .template import RobustnessTemplateRobustnessLiteral = Literal["input overreliance", "hijacking"]@@ -14,9 +23,12 @@ class Robustness(BaseVulnerability):def __init__(self,purpose: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[RobustnessLiteral]] = [type.value for type in RobustnessType],@@ -25,27 +37,256 @@ class Robustness(BaseVulnerability):self.get_name(), types=types, allowed_type=RobustnessType)self.purpose = purpose- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )+ from deepteam.risks import getRiskCategory++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[RobustnessType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )+ from deepteam.risks import getRiskCategory++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[RobustnessType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.attacks.attack_simulator import SimulatedAttack++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ RobustnessTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.attacks.attack_simulator import SimulatedAttack++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ RobustnessTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+# TODO: Different metrics for different types. Forces us to use type in the `_get_metric` call.def _get_metric(self,type: RobustnessType,- ):+ ) -> BaseRedTeamingMetric:if type == RobustnessType.HIJACKING:return HijackingMetric(purpose=self.purpose,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)if type == RobustnessType.INPUT_OVERRELIANCE:return OverrelianceMetric(purpose=self.purpose,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/base_vulnerability.py b/deepteam/vulnerabilities/base_vulnerability.pyindex bf3400fd..a493d0fc 100644--- a/deepteam/vulnerabilities/base_vulnerability.py+++ b/deepteam/vulnerabilities/base_vulnerability.py@@ -1,7 +1,6 @@from typing import Listfrom enum import Enumfrom abc import ABC-from deepteam.metrics import BaseRedTeamingMetric@@ -28,6 +27,18 @@ class BaseVulnerability(ABC)::return: List of string values from the Enum types."""return [t.value for t in self.types]++ def assess(self):+ pass++ async def a_assess(self):+ pass++ def simulate_attacks(self):+ pass++ async def a_simulate_attacks(self):+ passdef _get_metric(self) -> BaseRedTeamingMetric:"""diff --git a/deepteam/vulnerabilities/bfla/bfla.py b/deepteam/vulnerabilities/bfla/bfla.pyindex 53e8406f..01e81779 100644--- a/deepteam/vulnerabilities/bfla/bfla.py+++ b/deepteam/vulnerabilities/bfla/bfla.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.bfla import BFLATypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import BFLAMetric+from deepteam.metrics import BFLAMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import BFLATemplateBFLALiteral = Literal["privilege_escalation",@@ -18,27 +29,255 @@ class BFLA(BaseVulnerability):def __init__(self,purpose: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[BFLALiteral]] = [type.value for type in BFLAType],):enum_types = validate_vulnerability_types(self.get_name(), types=types, allowed_type=BFLAType)self.purpose = purpose- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[BFLAType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[BFLAType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ BFLATemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ BFLATemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: BFLAType,- ):+ ) -> BaseRedTeamingMetric:return BFLAMetric(purpose=self.purpose,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/bola/bola.py b/deepteam/vulnerabilities/bola/bola.pyindex 070c8169..469a344d 100644--- a/deepteam/vulnerabilities/bola/bola.py+++ b/deepteam/vulnerabilities/bola/bola.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.bola import BOLATypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import BOLAMetric+from deepteam.metrics import BOLAMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import BOLATemplateBOLALiteral = Literal["object_access_bypass",@@ -17,25 +28,253 @@ BOLALiteral = Literal[class BOLA(BaseVulnerability):def __init__(self,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[BOLALiteral]] = [type.value for type in BOLAType],):enum_types = validate_vulnerability_types(self.get_name(), types=types, allowed_type=BOLAType)- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[BOLAType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[BOLAType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ BOLATemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ BOLATemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: BOLAType,- ):+ ) -> BaseRedTeamingMetric:return BOLAMetric(- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/competition/competition.py b/deepteam/vulnerabilities/competition/competition.pyindex c8f545cb..8253d01c 100644--- a/deepteam/vulnerabilities/competition/competition.py+++ b/deepteam/vulnerabilities/competition/competition.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.competition import CompetitionTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import CompetitorsMetric+from deepteam.metrics import CompetitorsMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import CompetitionTemplateCompetitionLiteralType = Literal[@@ -20,9 +31,12 @@ class Competition(BaseVulnerability):def __init__(self,purpose: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[CompetitionLiteralType]] = [type.value for type in CompetitionType],@@ -31,18 +45,243 @@ class Competition(BaseVulnerability):self.get_name(), types=types, allowed_type=CompetitionType)self.purpose = purpose- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[CompetitionType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[CompetitionType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ CompetitionTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ CompetitionTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: CompetitionType,- ):+ ) -> BaseRedTeamingMetric:return CompetitorsMetric(purpose=self.purpose,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/custom/custom.py b/deepteam/vulnerabilities/custom/custom.pyindex b2f83289..56ae64f4 100644--- a/deepteam/vulnerabilities/custom/custom.py+++ b/deepteam/vulnerabilities/custom/custom.py@@ -1,11 +1,20 @@-from typing import List, Optional, Union+from typing import List, Literal, Optional, Union, Dictfrom enum import Enum+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.metrics import BaseRedTeamingMetric, HarmMetric-+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import CustomVulnerabilityTemplateclass CustomVulnerability(BaseVulnerability):"""@@ -19,9 +28,12 @@ class CustomVulnerability(BaseVulnerability):types: Optional[List[str]] = None,custom_prompt: Optional[str] = None,metric: Optional[BaseRedTeamingMetric] = None,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",):self.name = name@@ -32,7 +44,8 @@ class CustomVulnerability(BaseVulnerability):self.custom_prompt = custom_promptself.criteria = criteria.strip()- self.model = model+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelself.async_mode = async_modeself.verbose_mode = verbose_modeif metric:@@ -40,7 +53,7 @@ class CustomVulnerability(BaseVulnerability):else:self.metric = HarmMetric(harm_category=self.criteria,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)@@ -51,8 +64,235 @@ class CustomVulnerability(BaseVulnerability):def get_custom_prompt(self) -> Optional[str]:return self.custom_prompt++ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[str, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[str, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack):+ from deepteam.attacks.attack_simulator import SimulatedAttack+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.attacks.attack_simulator import SimulatedAttack++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ CustomVulnerabilityTemplate.generate_baseline_attacks(+ self.name, type, attacks_per_vulnerability_type, self.custom_prompt+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.attacks.attack_simulator import SimulatedAttack++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ CustomVulnerabilityTemplate.generate_baseline_attacks(+ self.name, type, attacks_per_vulnerability_type, self.custom_prompt+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks- def _get_metric(self, type: Enum) -> Optional[BaseRedTeamingMetric]:+ def _get_metric(self, type: Enum) -> BaseRedTeamingMetric:return self.metricdef get_criteria(self) -> str:diff --git a/deepteam/vulnerabilities/debug_access/debug_access.py b/deepteam/vulnerabilities/debug_access/debug_access.pyindex a0dadeb3..1cdfb05b 100644--- a/deepteam/vulnerabilities/debug_access/debug_access.py+++ b/deepteam/vulnerabilities/debug_access/debug_access.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.debug_access import DebugAccessTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import DebugAccessMetric+from deepteam.metrics import DebugAccessMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import DebugAccessTemplateDebugAccessLiteral = Literal["debug_mode_bypass",@@ -17,9 +28,12 @@ DebugAccessLiteral = Literal[class DebugAccess(BaseVulnerability):def __init__(self,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[DebugAccessLiteral]] = [type.value for type in DebugAccessType],@@ -27,17 +41,242 @@ class DebugAccess(BaseVulnerability):enum_types = validate_vulnerability_types(self.get_name(), types=types, allowed_type=DebugAccessType)- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[DebugAccessType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[DebugAccessType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ DebugAccessTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ DebugAccessTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: DebugAccessType,- ):+ ) -> BaseRedTeamingMetric:return DebugAccessMetric(- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/graphic_content/graphic_content.py b/deepteam/vulnerabilities/graphic_content/graphic_content.pyindex 32d8eb59..207cc472 100644--- a/deepteam/vulnerabilities/graphic_content/graphic_content.py+++ b/deepteam/vulnerabilities/graphic_content/graphic_content.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.graphic_content import GraphicContentTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import GraphicMetric+from deepteam.metrics import GraphicMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import GraphicContentTemplateGraphicContentLiteral = Literal["sexual content", "graphic content", "pornographic content"@@ -16,9 +27,12 @@ class GraphicContent(BaseVulnerability):def __init__(self,graphic_category: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[GraphicContentLiteral]] = [type.value for type in GraphicContentType],@@ -27,18 +41,243 @@ class GraphicContent(BaseVulnerability):self.get_name(), types=types, allowed_type=GraphicContentType)self.graphic_category = graphic_category- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[GraphicContentType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[GraphicContentType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ GraphicContentTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.graphic_category+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ GraphicContentTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.graphic_category+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: GraphicContentType,- ):+ ) -> BaseRedTeamingMetric:return GraphicMetric(graphic_category=self.graphic_category,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/illegal_activity/illegal_activity.py b/deepteam/vulnerabilities/illegal_activity/illegal_activity.pyindex a62dbb0c..80aa731b 100644--- a/deepteam/vulnerabilities/illegal_activity/illegal_activity.py+++ b/deepteam/vulnerabilities/illegal_activity/illegal_activity.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.illegal_activity import IllegalActivityTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import IllegalMetric+from deepteam.metrics import IllegalMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import IllegalActivityTemplateIllegalActivityLiteral = Literal["weapons",@@ -22,9 +33,12 @@ class IllegalActivity(BaseVulnerability):def __init__(self,illegal_category: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[IllegalActivityLiteral]] = [type.value for type in IllegalActivityType],@@ -33,18 +47,243 @@ class IllegalActivity(BaseVulnerability):self.get_name(), types=types, allowed_type=IllegalActivityType)self.illegal_category = illegal_category- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[IllegalActivityType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[IllegalActivityType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ IllegalActivityTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.illegal_category+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ IllegalActivityTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.illegal_category+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: IllegalActivityType,- ):+ ) -> BaseRedTeamingMetric:return IllegalMetric(illegal_category=self.illegal_category,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/intellectual_property/intellectual_property.py b/deepteam/vulnerabilities/intellectual_property/intellectual_property.pyindex 802e52ef..62afdbca 100644--- a/deepteam/vulnerabilities/intellectual_property/intellectual_property.py+++ b/deepteam/vulnerabilities/intellectual_property/intellectual_property.py@@ -1,15 +1,24 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase-from deepeval.models import DeepEvalBaseLLM+from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.intellectual_property import (IntellectualPropertyType,)from deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import IntellectualPropertyMetric+from deepteam.metrics import IntellectualPropertyMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import IntellectualPropertyTemplateIntellectualPropertyLiteral = Literal["imitation",@@ -23,9 +32,12 @@ class IntellectualProperty(BaseVulnerability):def __init__(self,purpose: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[IntellectualPropertyLiteral]] = [type.value for type in IntellectualPropertyType],@@ -34,18 +46,243 @@ class IntellectualProperty(BaseVulnerability):self.get_name(), types=types, allowed_type=IntellectualPropertyType)self.purpose = purpose- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[IntellectualPropertyType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[IntellectualPropertyType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ IntellectualPropertyTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ IntellectualPropertyTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: IntellectualPropertyType,- ):+ ) -> BaseRedTeamingMetric:return IntellectualPropertyMetric(purpose=self.purpose,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/misinformation/misinformation.py b/deepteam/vulnerabilities/misinformation/misinformation.pyindex 9de9889e..58f7e83d 100644--- a/deepteam/vulnerabilities/misinformation/misinformation.py+++ b/deepteam/vulnerabilities/misinformation/misinformation.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.misinformation import MisinformationTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import MisinformationMetric+from deepteam.metrics import MisinformationMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import MisinformationTemplateMisinformationLiteral = Literal[@@ -17,9 +28,12 @@ class Misinformation(BaseVulnerability):def __init__(self,misinformation_category: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[MisinformationLiteral]] = [type.value for type in MisinformationType],@@ -28,18 +42,243 @@ class Misinformation(BaseVulnerability):self.get_name(), types=types, allowed_type=MisinformationType)self.misinformation_category = misinformation_category- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[MisinformationType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[MisinformationType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ MisinformationTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.misinformation_category+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ MisinformationTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.misinformation_category+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: MisinformationType,- ):+ ) -> BaseRedTeamingMetric:return MisinformationMetric(misinformation_category=self.misinformation_category,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/personal_safety/personal_safety.py b/deepteam/vulnerabilities/personal_safety/personal_safety.pyindex c5894283..65ca78e2 100644--- a/deepteam/vulnerabilities/personal_safety/personal_safety.py+++ b/deepteam/vulnerabilities/personal_safety/personal_safety.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.personal_safety import PersonalSafetyTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import SafetyMetric+from deepteam.metrics import SafetyMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import PersonalSafetyTemplatePersonalSafetyLiteral = Literal["bullying",@@ -20,9 +31,12 @@ class PersonalSafety(BaseVulnerability):def __init__(self,safety_category: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[PersonalSafetyLiteral]] = [type.value for type in PersonalSafetyType],@@ -31,18 +45,243 @@ class PersonalSafety(BaseVulnerability):self.get_name(), types=types, allowed_type=PersonalSafetyType)self.safety_category = safety_category- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[PersonalSafetyType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[PersonalSafetyType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ PersonalSafetyTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.safety_category+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ PersonalSafetyTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.safety_category+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: PersonalSafetyType,- ):+ ) -> BaseRedTeamingMetric:return SafetyMetric(safety_category=self.safety_category,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/pii_leakage/pii_leakage.py b/deepteam/vulnerabilities/pii_leakage/pii_leakage.pyindex e77b5e33..31fd84db 100644--- a/deepteam/vulnerabilities/pii_leakage/pii_leakage.py+++ b/deepteam/vulnerabilities/pii_leakage/pii_leakage.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.pii_leakage import PIILeakageTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import PIIMetric+from deepteam.metrics import PIIMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import PIILeakageTemplatePIILeakageLiteral = Literal["api and database access",@@ -19,9 +30,12 @@ class PIILeakage(BaseVulnerability):def __init__(self,purpose: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[PIILeakageLiteral]] = [type.value for type in PIILeakageType],@@ -30,18 +44,243 @@ class PIILeakage(BaseVulnerability):self.get_name(), types=types, allowed_type=PIILeakageType)self.purpose = purpose- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[PIILeakageType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[PIILeakageType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ PIILeakageTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ PIILeakageTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: PIILeakageType,- ):+ ) -> BaseRedTeamingMetric:return PIIMetric(purpose=self.purpose,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/prompt_leakage/prompt_leakage.py b/deepteam/vulnerabilities/prompt_leakage/prompt_leakage.pyindex ed53fa90..e08b7af7 100644--- a/deepteam/vulnerabilities/prompt_leakage/prompt_leakage.py+++ b/deepteam/vulnerabilities/prompt_leakage/prompt_leakage.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.prompt_leakage import PromptLeakageTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import PromptExtractionMetric+from deepteam.metrics import PromptExtractionMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import PromptLeakageTemplatePromptLeakageLiteral = Literal["secrets and credentials",@@ -19,9 +30,12 @@ class PromptLeakage(BaseVulnerability):def __init__(self,purpose: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[PromptLeakageLiteral]] = [type.value for type in PromptLeakageType],@@ -30,18 +44,243 @@ class PromptLeakage(BaseVulnerability):self.get_name(), types=types, allowed_type=PromptLeakageType)self.purpose = purpose- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[PromptLeakageType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[PromptLeakageType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ PromptLeakageTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ PromptLeakageTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: PromptLeakageType,- ):+ ) -> BaseRedTeamingMetric:return PromptExtractionMetric(purpose=self.purpose,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/rbac/rbac.py b/deepteam/vulnerabilities/rbac/rbac.pyindex a09453e7..aeef3be1 100644--- a/deepteam/vulnerabilities/rbac/rbac.py+++ b/deepteam/vulnerabilities/rbac/rbac.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.rbac import RBACTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import RBACMetric+from deepteam.metrics import RBACMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import RBACTemplateRBACLiteral = Literal["role_bypass",@@ -18,27 +29,255 @@ class RBAC(BaseVulnerability):def __init__(self,purpose: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[RBACLiteral]] = [type.value for type in RBACType],):enum_types = validate_vulnerability_types(self.get_name(), types=types, allowed_type=RBACType)self.purpose = purpose- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[RBACType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[RBACType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ RBACTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ RBACTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: RBACType,- ):+ ) -> BaseRedTeamingMetric:return RBACMetric(purpose=self.purpose,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/shell_injection/shell_injection.py b/deepteam/vulnerabilities/shell_injection/shell_injection.pyindex 813fccc3..9839ca0a 100644--- a/deepteam/vulnerabilities/shell_injection/shell_injection.py+++ b/deepteam/vulnerabilities/shell_injection/shell_injection.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.shell_injection import ShellInjectionTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import ShellInjectionMetric+from deepteam.metrics import ShellInjectionMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import ShellInjectionTemplateShellInjectionLiteral = Literal["command_injection",@@ -17,9 +28,12 @@ ShellInjectionLiteral = Literal[class ShellInjection(BaseVulnerability):def __init__(self,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[ShellInjectionLiteral]] = [type.value for type in ShellInjectionType],@@ -27,17 +41,242 @@ class ShellInjection(BaseVulnerability):enum_types = validate_vulnerability_types(self.get_name(), types=types, allowed_type=ShellInjectionType)- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)++ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[ShellInjectionType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[ShellInjectionType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ ShellInjectionTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ ShellInjectionTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacksdef _get_metric(self,type: ShellInjectionType,- ):+ ) -> BaseRedTeamingMetric:return ShellInjectionMetric(- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/sql_injection/sql_injection.py b/deepteam/vulnerabilities/sql_injection/sql_injection.pyindex ec20c5b8..6bc48468 100644--- a/deepteam/vulnerabilities/sql_injection/sql_injection.py+++ b/deepteam/vulnerabilities/sql_injection/sql_injection.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.sql_injection import SQLInjectionTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import SQLInjectionMetric+from deepteam.metrics import SQLInjectionMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import SQLInjectionTemplateSQLInjectionLiteral = Literal["blind_sql_injection",@@ -17,9 +28,12 @@ SQLInjectionLiteral = Literal[class SQLInjection(BaseVulnerability):def __init__(self,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[SQLInjectionLiteral]] = [type.value for type in SQLInjectionType],@@ -27,17 +41,242 @@ class SQLInjection(BaseVulnerability):enum_types = validate_vulnerability_types(self.get_name(), types=types, allowed_type=SQLInjectionType)- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)++ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[SQLInjectionType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[SQLInjectionType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ SQLInjectionTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ SQLInjectionTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacksdef _get_metric(self,type: SQLInjectionType,- ):+ ) -> BaseRedTeamingMetric:return SQLInjectionMetric(- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/ssrf/ssrf.py b/deepteam/vulnerabilities/ssrf/ssrf.pyindex fa8c766a..a468f306 100644--- a/deepteam/vulnerabilities/ssrf/ssrf.py+++ b/deepteam/vulnerabilities/ssrf/ssrf.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.ssrf import SSRFTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import SSRFMetric+from deepteam.metrics import SSRFMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import SSRFTemplateSSRFLiteral = Literal["internal_service_access",@@ -18,27 +29,255 @@ class SSRF(BaseVulnerability):def __init__(self,purpose: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[SSRFLiteral]] = [type.value for type in SSRFType],):enum_types = validate_vulnerability_types(self.get_name(), types=types, allowed_type=SSRFType)self.purpose = purpose- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)++ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[SSRFType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[SSRFType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ SSRFTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ SSRFTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacksdef _get_metric(self,type: SSRFType,- ):+ ) -> BaseRedTeamingMetric:return SSRFMetric(purpose=self.purpose,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)diff --git a/deepteam/vulnerabilities/toxicity/toxicity.py b/deepteam/vulnerabilities/toxicity/toxicity.pyindex f956c1e9..b165fa82 100644--- a/deepteam/vulnerabilities/toxicity/toxicity.py+++ b/deepteam/vulnerabilities/toxicity/toxicity.py@@ -1,11 +1,22 @@-from typing import List, Literal, Optional, Union+from typing import List, Literal, Optional, Union, Dict+import asynciofrom deepeval.models import DeepEvalBaseLLM+from deepeval.metrics.utils import initialize_model, trimAndLoadJson+from deepeval.utils import get_or_create_event_loop+from deepeval.test_case import LLMTestCase++from deepteam.utils import validate_model_callback_signaturefrom deepteam.vulnerabilities import BaseVulnerabilityfrom deepteam.vulnerabilities.toxicity import ToxicityTypefrom deepteam.vulnerabilities.utils import validate_vulnerability_types-from deepteam.metrics import ToxicityMetric+from deepteam.metrics import ToxicityMetric, BaseRedTeamingMetric+from deepteam.attacks.multi_turn.types import CallbackType+from deepteam.attacks.attack_simulator import SimulatedAttack+from deepteam.attacks.attack_simulator.schema import SyntheticDataList+from deepteam.risks import getRiskCategory+from .template import ToxicityTemplateToxicityLiteral = Literal["profanity", "insults", "threats", "mockery"]@@ -14,9 +25,12 @@ class Toxicity(BaseVulnerability):def __init__(self,toxicity_category: str,- model: Optional[Union[str, DeepEvalBaseLLM]] = None,async_mode: bool = True,verbose_mode: bool = False,+ simulator_model: Optional[+ Union[str, DeepEvalBaseLLM]+ ] = "gpt-3.5-turbo-0125",+ evaluation_model: Optional[Union[str, DeepEvalBaseLLM]] = "gpt-4o",types: Optional[List[ToxicityLiteral]] = [type.value for type in ToxicityType],@@ -25,18 +39,243 @@ class Toxicity(BaseVulnerability):self.get_name(), types=types, allowed_type=ToxicityType)self.toxicity_category = toxicity_category- self.model = modelself.async_mode = async_modeself.verbose_mode = verbose_mode+ self.simulator_model = simulator_model+ self.evaluation_model = evaluation_modelsuper().__init__(types=enum_types)+ def assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ if self.async_mode:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )+ loop = get_or_create_event_loop()+ return loop.run_until_complete(+ self.a_assess(+ model_callback=model_callback,+ attacks_per_vulnerability_type=attacks_per_vulnerability_type,+ )+ )+ else:+ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = self.simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[ToxicityType, List[RedTeamingTestCase]] = dict()++ for simulated_attack in simulated_attacks:+ vulnerability_type = simulated_attack.vulnerability_type++ target_output = model_callback(simulated_attack.input)+ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric = self._get_metric(vulnerability_type)+ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ results[vulnerability_type] = results.get(vulnerability_type, [])+ results[vulnerability_type].append(red_teaming_test_case)++ return results++ async def a_assess(+ self,+ model_callback: CallbackType,+ attacks_per_vulnerability_type: int = 1,+ ):+ from deepteam.red_teamer.risk_assessment import (+ RedTeamingTestCase,+ )++ validate_model_callback_signature(+ model_callback=model_callback,+ async_mode=self.async_mode,+ )++ simulated_attacks = await self.a_simulate_attacks(+ attacks_per_vulnerability_type+ )++ results: Dict[ToxicityType, List[RedTeamingTestCase]] = dict()++ async def process_attack(simulated_attack: SimulatedAttack):+ vulnerability_type = simulated_attack.vulnerability_type++ metric = self._get_metric(vulnerability_type)+ target_output = await model_callback(simulated_attack.input)++ test_case = LLMTestCase(+ input=simulated_attack.input,+ actual_output=target_output,+ )++ metric.measure(test_case)++ red_teaming_test_case = RedTeamingTestCase(+ vulnerability=simulated_attack.vulnerability,+ vulnerability_type=vulnerability_type,+ attackMethod=simulated_attack.attack_method,+ riskCategory=getRiskCategory(vulnerability_type),+ input=simulated_attack.input,+ actual_output=target_output,+ score=metric.score,+ reason=metric.reason,+ )++ return vulnerability_type, red_teaming_test_case++ # Run all processing concurrently+ all_tasks = [+ process_attack(simulated_attack)+ for simulated_attack in simulated_attacks+ if simulated_attack.vulnerability_type in self.types+ ]++ for task in asyncio.as_completed(all_tasks):+ vulnerability_type, test_case = await task+ results.setdefault(vulnerability_type, []).append(test_case)++ return results++ def simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ ToxicityTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = self.simulator_model.generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = self.simulator_model.generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks++ async def a_simulate_attacks(+ self,+ attacks_per_vulnerability_type: int = 1,+ ) -> List[SimulatedAttack]:++ self.simulator_model, self.using_native_model = initialize_model(+ self.simulator_model+ )++ templates = dict()+ simulated_attacks: List[SimulatedAttack] = []++ for type in self.types:+ templates[type] = templates.get(type, [])+ templates[type].append(+ ToxicityTemplate.generate_baseline_attacks(+ type, attacks_per_vulnerability_type, self.purpose+ )+ )++ for type in self.types:+ for prompt in templates[type]:+ if self.using_native_model:+ res, _ = await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ local_attacks = [item.input for item in res.data]+ else:+ try:+ res: SyntheticDataList = (+ await self.simulator_model.a_generate(+ prompt, schema=SyntheticDataList+ )+ )+ local_attacks = [item.input for item in res.data]+ except TypeError:+ res = await self.simulator_model.a_generate(prompt)+ data = trimAndLoadJson(res)+ local_attacks = [item["input"] for item in data["data"]]++ simulated_attacks.extend(+ [+ SimulatedAttack(+ vulnerability=self.get_name(),+ vulnerability_type=type,+ input=local_attack,+ )+ for local_attack in local_attacks+ ]+ )++ return simulated_attacks+def _get_metric(self,type: ToxicityType,- ):+ ) -> BaseRedTeamingMetric:return ToxicityMetric(toxicity_category=self.toxicity_category,- model=self.model,+ model=self.evaluation_model,async_mode=self.async_mode,verbose_mode=self.verbose_mode,)