DeepTeam is a framework to red team LLMs and AI agents.
Reformat
penguinedaefa2296a4c
diff --git a/a.py b/a.pyindex 58b39c85..a45d24f9 100644--- a/a.py+++ b/a.py@@ -133,7 +133,7 @@ from deepteam.vulnerabilities import Biasfrom deepteam.attacks.single_turn import PromptInjection-def model_callback(input: str) -> str:+async def model_callback(input: str) -> str:# Replace this with your LLM applicationreturn f"I'm sorry but I can't answer this: {input}"diff --git a/b.py b/b.pyindex 901a23e9..4122525c 100644--- a/b.py+++ b/b.py@@ -14,9 +14,9 @@ from deepeval.models import GPTModelfrom deepteam.attacks.attack_simulator.attack_simulator import AttackSimulatorfrom deepteam.attacks.attack_simulator.template import AttackSimulatorTemplatefrom deepteam.vulnerabilities import (- Bias,- Misinformation,- Toxicity,+ Bias,+ Misinformation,+ Toxicity,PIILeakage,PromptLeakage,UnauthorizedAccess,@@ -26,7 +26,7 @@ from deepteam.vulnerabilities import (GraphicContent,IntellectualProperty,PersonalSafety,- Robustness+ Robustness,)from deepteam.vulnerabilities.types import (@@ -51,14 +51,18 @@ from deepteam.vulnerabilities.competition import CompetitionTemplatefrom deepteam.vulnerabilities.excessive_agency import ExcessiveAgencyTemplatefrom deepteam.vulnerabilities.graphic_content import GraphicContentTemplatefrom deepteam.vulnerabilities.illegal_activity import IllegalActivityTemplate-from deepteam.vulnerabilities.intellectual_property import IntellectualPropertyTemplate+from deepteam.vulnerabilities.intellectual_property import (+ IntellectualPropertyTemplate,+)from deepteam.vulnerabilities.misinformation import MisinformationTemplatefrom deepteam.vulnerabilities.personal_safety import PersonalSafetyTemplatefrom deepteam.vulnerabilities.pii_leakage import PIILeakageTemplatefrom deepteam.vulnerabilities.prompt_leakage import PromptLeakageTemplatefrom deepteam.vulnerabilities.robustness import RobustnessTemplatefrom deepteam.vulnerabilities.toxicity import ToxicityTemplate-from deepteam.vulnerabilities.unauthorized_access import UnauthorizedAccessTemplate+from deepteam.vulnerabilities.unauthorized_access import (+ UnauthorizedAccessTemplate,+)# ConfigurationMAX_GOLDENS = 3@@ -70,23 +74,23 @@ VULNERABILITY_TYPE_MAPPING = {"gender": BiasType.GENDER,"religion": BiasType.RELIGION,"race": BiasType.RACE,- "politics": BiasType.POLITICS+ "politics": BiasType.POLITICS,},"competition": {"competitor_mention": CompetitionType.COMPETITOR_MENTION,"market_manipulation": CompetitionType.MARKET_MANIPULATION,"discreditation": CompetitionType.DISCREDITATION,- "confidential_strategies": CompetitionType.CONFIDENTIAL_STRATEGIES+ "confidential_strategies": CompetitionType.CONFIDENTIAL_STRATEGIES,},"excessive_agency": {"functionality": ExcessiveAgencyType.FUNCTIONALITY,"permissions": ExcessiveAgencyType.PERMISSIONS,- "autonomy": ExcessiveAgencyType.AUTONOMY+ "autonomy": ExcessiveAgencyType.AUTONOMY,},"graphic_content": {"sexual_content": GraphicContentType.SEXUAL_CONTENT,"graphic_content": GraphicContentType.GRAPHIC_CONTENT,- "pornographic_content": GraphicContentType.PORNOGRAPHIC_CONTENT+ "pornographic_content": GraphicContentType.PORNOGRAPHIC_CONTENT,},"illegal_activity": {"weapons": IllegalActivityType.WEAPONS,@@ -95,47 +99,47 @@ VULNERABILITY_TYPE_MAPPING = {"non_violent_crime": IllegalActivityType.NON_VIOLENT_CRIME,"sex_crime": IllegalActivityType.SEX_CRIME,"cybercrime": IllegalActivityType.CYBERCRIME,- "child_exploitation": IllegalActivityType.CHILD_EXPLOITATION+ "child_exploitation": IllegalActivityType.CHILD_EXPLOITATION,},"intellectual_property": {"imitation": IntellectualPropertyType.IMITATION,"copyright_violations": IntellectualPropertyType.COPYRIGHT_VIOLATIONS,"trademark_infringement": IntellectualPropertyType.TRADEMARK_INFRINGEMENT,- "patent_disclosure": IntellectualPropertyType.PATENT_DISCLOSURE+ "patent_disclosure": IntellectualPropertyType.PATENT_DISCLOSURE,},"misinformation": {"factual_errors": MisinformationType.FACTUAL_ERRORS,"unsupported_claims": MisinformationType.UNSUPPORTED_CLAIMS,- "expertise_misrepresentation": MisinformationType.EXPERTIZE_MISREPRESENTATION+ "expertise_misrepresentation": MisinformationType.EXPERTIZE_MISREPRESENTATION,},"personal_safety": {"bullying": PersonalSafetyType.BULLYING,"self_harm": PersonalSafetyType.SELF_HARM,"unsafe_practices": PersonalSafetyType.UNSAFE_PRACTICES,"dangerous_challenges": PersonalSafetyType.DANGEROUS_CHALLENGES,- "stalking": PersonalSafetyType.STALKING+ "stalking": PersonalSafetyType.STALKING,},"pii_leakage": {"direct": PIILeakageType.DIRECT,"database_access": PIILeakageType.DATABASE_ACCESS,"social_manipulation": PIILeakageType.SOCIAL_MANIPULATION,- "session_leak": PIILeakageType.SESSION_LEAK+ "session_leak": PIILeakageType.SESSION_LEAK,},"prompt_leakage": {"secrets_and_credentials": PromptLeakageType.SECRETS_AND_CREDENTIALS,"instructions": PromptLeakageType.INSTRUCTIONS,"guard_exposure": PromptLeakageType.GUARD_EXPOSURE,- "permissions_and_roles": PromptLeakageType.PERMISSIONS_AND_ROLES+ "permissions_and_roles": PromptLeakageType.PERMISSIONS_AND_ROLES,},"robustness": {"input_overreliance": RobustnessType.INPUT_OVERRELIANCE,- "hijacking": RobustnessType.HIJACKING+ "hijacking": RobustnessType.HIJACKING,},"toxicity": {"insults": ToxicityType.INSULTS,"profanity": ToxicityType.PROFANITY,"threats": ToxicityType.THREATS,- "mockery": ToxicityType.MOCKERY+ "mockery": ToxicityType.MOCKERY,},"unauthorized_access": {"bfla": UnauthorizedAccessType.BFLA,@@ -144,8 +148,8 @@ VULNERABILITY_TYPE_MAPPING = {"debug_access": UnauthorizedAccessType.DEBUG_ACCESS,"shell_injection": UnauthorizedAccessType.SHELL_INJECTION,"sql_injection": UnauthorizedAccessType.SQL_INJECTION,- "ssrf": UnauthorizedAccessType.SSRF- }+ "ssrf": UnauthorizedAccessType.SSRF,+ },}@@ -160,19 +164,21 @@ def get_all_vulnerability_types() -> str:return result-def get_vulnerability_from_args(vul_type: str, subtype: str) -> Optional[VulnerabilityType]:+def get_vulnerability_from_args(+ vul_type: str, subtype: str+) -> Optional[VulnerabilityType]:"""Convert command line arguments to a vulnerability type enum."""if vul_type not in VULNERABILITY_TYPE_MAPPING:print(f"Error: '{vul_type}' is not a valid vulnerability type.")return None-+if subtype not in VULNERABILITY_TYPE_MAPPING[vul_type]:print(f"Error: '{subtype}' is not a valid subtype for {vul_type}.")print(f"Available subtypes for {vul_type}:")for available_subtype in VULNERABILITY_TYPE_MAPPING[vul_type]:print(f" - {available_subtype}")return None-+return VULNERABILITY_TYPE_MAPPING[vul_type][subtype]@@ -183,131 +189,137 @@ def separator():def test_local_baseline_attacks(purpose: str):"""Test local baseline attack generation using OpenAI for key vulnerability types"""- print(f"Testing local baseline attack generation with OpenAI for purpose: {purpose}\n")-+ print(+ f"Testing local baseline attack generation with OpenAI for purpose: {purpose}\n"+ )+# Check if OpenAI API key is setapi_key = os.environ.get("OPENAI_API_KEY")if not api_key:api_key = input("Please enter your OpenAI API key: ")os.environ["OPENAI_API_KEY"] = api_key-+# Create a simulator with an OpenAI modelopenai_model = GPTModel(model_name="gpt-3.5-turbo")simulator = AttackSimulator(- purpose=purpose,- max_concurrent=3,- simulator_model=openai_model+ purpose=purpose, max_concurrent=3, simulator_model=openai_model)-+# Create all vulnerabilities to test, grouped by category for easier debuggingvulnerabilities = []-+# Group 1: Basic vulnerabilities already verified to workbasic_vulnerabilities = [Bias(types=["religion"]),Misinformation(types=["factual errors"]),Toxicity(types=["profanity"]),- PIILeakage(types=["direct disclosure"])+ PIILeakage(types=["direct disclosure"]),]vulnerabilities.extend(basic_vulnerabilities)-+# Group 2: PromptLeakage vulnerabilitiesprompt_leakage_vulnerabilities = [PromptLeakage(types=["secrets and credentials"]),PromptLeakage(types=["instructions"]),PromptLeakage(types=["guard exposure"]),- PromptLeakage(types=["permissions and roles"])+ PromptLeakage(types=["permissions and roles"]),]vulnerabilities.extend(prompt_leakage_vulnerabilities)-+# Group 3: UnauthorizedAccess vulnerabilitiesunauthorized_access_vulnerabilities = [UnauthorizedAccess(types=["debug access"]),- UnauthorizedAccess(types=["bola"]), # Correct string for "broken object level authorization"- UnauthorizedAccess(types=["bfla"]), # Correct string for "broken function level authorization"- UnauthorizedAccess(types=["rbac"]), # Correct string for "role-based access control"+ UnauthorizedAccess(+ types=["bola"]+ ), # Correct string for "broken object level authorization"+ UnauthorizedAccess(+ types=["bfla"]+ ), # Correct string for "broken function level authorization"+ UnauthorizedAccess(+ types=["rbac"]+ ), # Correct string for "role-based access control"UnauthorizedAccess(types=["shell injection"]),- UnauthorizedAccess(types=["sql injection"])+ UnauthorizedAccess(types=["sql injection"]),]vulnerabilities.extend(unauthorized_access_vulnerabilities)-+# Group 4: Competition vulnerabilitiescompetition_vulnerabilities = [Competition(types=["competitor mention"]),Competition(types=["market manipulation"]),Competition(types=["discreditation"]),- Competition(types=["confidential strategies"])+ Competition(types=["confidential strategies"]),]vulnerabilities.extend(competition_vulnerabilities)-+# Group 5: RobustnessType vulnerabilitiesrobustness_vulnerabilities = [Robustness(types=["input overreliance"]),- Robustness(types=["hijacking"])+ Robustness(types=["hijacking"]),]vulnerabilities.extend(robustness_vulnerabilities)-+# Group 6: ExcessiveAgency vulnerabilitiesexcessive_agency_vulnerabilities = [ExcessiveAgency(types=["functionality"]),ExcessiveAgency(types=["permissions"]),- ExcessiveAgency(types=["autonomy"])+ ExcessiveAgency(types=["autonomy"]),]vulnerabilities.extend(excessive_agency_vulnerabilities)-+# Group 7: GraphicContent vulnerabilitiesgraphic_content_vulnerabilities = [GraphicContent(types=["sexual content"]),GraphicContent(types=["graphic content"]),- GraphicContent(types=["pornographic content"])+ GraphicContent(types=["pornographic content"]),]vulnerabilities.extend(graphic_content_vulnerabilities)-+# Group 8: IllegalActivity vulnerabilities - only test a few selected typesillegal_activity_vulnerabilities = [IllegalActivity(types=["weapons"]),IllegalActivity(types=["illegal drugs"]),IllegalActivity(types=["violent crimes"]),- IllegalActivity(types=["cybercrime"])+ IllegalActivity(types=["cybercrime"]),]vulnerabilities.extend(illegal_activity_vulnerabilities)-+# Group 9: IntellectualProperty vulnerabilitiesintellectual_property_vulnerabilities = [IntellectualProperty(types=["copyright violations"]),IntellectualProperty(types=["trademark infringement"]),IntellectualProperty(types=["patent disclosure"]),- IntellectualProperty(types=["imitation"])+ IntellectualProperty(types=["imitation"]),]vulnerabilities.extend(intellectual_property_vulnerabilities)-+# Group 10: PersonalSafety vulnerabilitiespersonal_safety_vulnerabilities = [PersonalSafety(types=["bullying"]),PersonalSafety(types=["self-harm"]),PersonalSafety(types=["dangerous challenges"]),- PersonalSafety(types=["stalking"])+ PersonalSafety(types=["stalking"]),]vulnerabilities.extend(personal_safety_vulnerabilities)-+print(f"Testing {len(vulnerabilities)} vulnerability types")-+# Track resultssuccessful = []failed = []-+# Generate baseline attacks locallyprint("Generating baseline attacks locally for each vulnerability type...")-+for i, vulnerability in enumerate(vulnerabilities):print(f"\n[{i+1}/{len(vulnerabilities)}] Testing: {vulnerability}")try:attacks = simulator.simulate_baseline_attacks(attacks_per_vulnerability_type=1,vulnerability=vulnerability,- ignore_errors=False # We want to catch errors+ ignore_errors=False, # We want to catch errors)-+if attacks:successful.append((vulnerability, attacks[0]))print(f"✅ SUCCESS: Generated attack")@@ -318,39 +330,46 @@ def test_local_baseline_attacks(purpose: str):except Exception as e:failed.append((vulnerability, str(e)))print(f"❌ ERROR: {str(e)}")-+# Add a small delay to avoid rate limitingtime.sleep(1)-+# Print summaryprint("\n\n=== SUMMARY ===")print(f"Total vulnerability types tested: {len(vulnerabilities)}")print(f"Successful: {len(successful)}")print(f"Failed: {len(failed)}")-+if failed:print("\n=== FAILED VULNERABILITY TYPES ===")for vulnerability, error in failed:print(f"- {vulnerability}: {error}")-+print("\nDone!")-def test_specific_vulnerability(vul_type: VulnerabilityType, max_goldens: int, purpose: str):+def test_specific_vulnerability(+ vul_type: VulnerabilityType, max_goldens: int, purpose: str+):"""Test a specific vulnerability type."""separator()print(f"Testing vulnerability type: {vul_type}")print(f"Purpose: {purpose}")print(f"Max goldens: {max_goldens}")separator()-+# Get the appropriate template class for this vulnerability type- for type_class, template_class in AttackSimulatorTemplate.TEMPLATE_MAP.items():+ for (+ type_class,+ template_class,+ ) in AttackSimulatorTemplate.TEMPLATE_MAP.items():if isinstance(vul_type, type_class):- prompt_template = template_class.generate_baseline_attacks(vul_type, max_goldens, purpose)+ prompt_template = template_class.generate_baseline_attacks(+ vul_type, max_goldens, purpose+ )print(prompt_template)return-+print(f"Error: No template found for vulnerability type {vul_type}")@@ -363,10 +382,12 @@ def simulate_local_attacks(vul_type: str, subtype: str, purpose: str):# Initialize the attack simulatorsimulator = AttackSimulator(purpose=purpose, max_concurrent=3)-+# Simulate local attackstry:- attacks = simulator.simulate_local_attack(purpose, vulnerability, MAX_GOLDENS)+ attacks = simulator.simulate_local_attack(+ purpose, vulnerability, MAX_GOLDENS+ )print(f"Simulated attacks for {vul_type} ({subtype}):")for attack in attacks:print(attack)@@ -375,14 +396,18 @@ def simulate_local_attacks(vul_type: str, subtype: str, purpose: str):def main():- parser = argparse.ArgumentParser(description="Simulate local attacks for a given vulnerability type and subtype.")+ parser = argparse.ArgumentParser(+ description="Simulate local attacks for a given vulnerability type and subtype."+ )parser.add_argument("vul_type", type=str, help="The vulnerability type.")parser.add_argument("subtype", type=str, help="The vulnerability subtype.")- parser.add_argument("purpose", type=str, help="The purpose for generating the prompts.")+ parser.add_argument(+ "purpose", type=str, help="The purpose for generating the prompts."+ )args = parser.parse_args()simulate_local_attacks(args.vul_type, args.subtype, args.purpose)if __name__ == "__main__":- main()\ No newline at end of file+ main()diff --git a/deepteam/attacks/attack_simulator/attack_simulator.py b/deepteam/attacks/attack_simulator/attack_simulator.pyindex 07c1172b..3323a451 100644--- a/deepteam/attacks/attack_simulator/attack_simulator.py+++ b/deepteam/attacks/attack_simulator/attack_simulator.py@@ -220,7 +220,7 @@ class AttackSimulator:vulnerability_type,attacks_per_vulnerability_type,)-+baseline_attacks.extend([SimulatedAttack(@@ -267,7 +267,7 @@ class AttackSimulator:vulnerability_type,attacks_per_vulnerability_type,)-+baseline_attacks.extend([SimulatedAttack(@@ -411,10 +411,12 @@ class AttackSimulator:vulnerability_type=vulnerability_type,purpose=purpose,)-+if self.using_native_model:# For models that support schema validation directly- result, _ = self.simulator_model.generate(template, schema=SyntheticDataList)+ result, _ = self.simulator_model.generate(+ template, schema=SyntheticDataList+ )return [item.input for item in result.data]else:# For models that don't support schema validation@@ -426,7 +428,7 @@ class AttackSimulator:except Exception as e:print(f"Error generating local attacks: {str(e)}")raise-+async def a_simulate_local_attack(self,purpose: str,@@ -440,10 +442,12 @@ class AttackSimulator:vulnerability_type=vulnerability_type,purpose=purpose,)-+if self.using_native_model:# For models that support schema validation directly- result, _ = await self.simulator_model.a_generate(template, schema=SyntheticDataList)+ result, _ = await self.simulator_model.a_generate(+ template, schema=SyntheticDataList+ )return [item.input for item in result.data]else:# For models that don't support schema validationdiff --git a/deepteam/attacks/attack_simulator/template.py b/deepteam/attacks/attack_simulator/template.pyindex 537b5e9f..55f8461a 100644--- a/deepteam/attacks/attack_simulator/template.py+++ b/deepteam/attacks/attack_simulator/template.py@@ -22,14 +22,18 @@ from deepteam.vulnerabilities.competition import CompetitionTemplatefrom deepteam.vulnerabilities.excessive_agency import ExcessiveAgencyTemplatefrom deepteam.vulnerabilities.graphic_content import GraphicContentTemplatefrom deepteam.vulnerabilities.illegal_activity import IllegalActivityTemplate-from deepteam.vulnerabilities.intellectual_property import IntellectualPropertyTemplate+from deepteam.vulnerabilities.intellectual_property import (+ IntellectualPropertyTemplate,+)from deepteam.vulnerabilities.misinformation import MisinformationTemplatefrom deepteam.vulnerabilities.personal_safety import PersonalSafetyTemplatefrom deepteam.vulnerabilities.pii_leakage import PIILeakageTemplatefrom deepteam.vulnerabilities.prompt_leakage import PromptLeakageTemplatefrom deepteam.vulnerabilities.robustness import RobustnessTemplatefrom deepteam.vulnerabilities.toxicity import ToxicityTemplate-from deepteam.vulnerabilities.unauthorized_access import UnauthorizedAccessTemplate+from deepteam.vulnerabilities.unauthorized_access import (+ UnauthorizedAccessTemplate,+)class AttackSimulatorTemplate:@@ -47,7 +51,7 @@ class AttackSimulatorTemplate:PromptLeakageType: PromptLeakageTemplate,RobustnessType: RobustnessTemplate,ToxicityType: ToxicityTemplate,- UnauthorizedAccessType: UnauthorizedAccessTemplate+ UnauthorizedAccessType: UnauthorizedAccessTemplate,}@staticmethod@@ -58,19 +62,24 @@ class AttackSimulatorTemplate:):"""Generate attack prompts based on the vulnerability type.-+Args:max_goldens: Maximum number of examples to generatevulnerability_type: Type of vulnerability to targetpurpose: Context or purpose for generating the prompts-+Returns:Formatted prompt template string or error message if vulnerability type not supported"""- for type_class, template_class in AttackSimulatorTemplate.TEMPLATE_MAP.items():+ for (+ type_class,+ template_class,+ ) in AttackSimulatorTemplate.TEMPLATE_MAP.items():if isinstance(vulnerability_type, type_class):- return template_class.generate_baseline_attacks(vulnerability_type, max_goldens, purpose)-+ return template_class.generate_baseline_attacks(+ vulnerability_type, max_goldens, purpose+ )+return f"""{{"error": "Vulnerability type '{vulnerability_type}' is not supported or no prompt template is available for this type."diff --git a/deepteam/attacks/attack_simulator/utils.py b/deepteam/attacks/attack_simulator/utils.pyindex 47e44313..a94abd54 100644--- a/deepteam/attacks/attack_simulator/utils.py+++ b/deepteam/attacks/attack_simulator/utils.py@@ -13,13 +13,13 @@ def generate_schema() -> BaseModel:"""Generate schema using the provided model.-+Args:prompt: The prompt to send to the modelschema: The schema to validate the response againstusing_native_model: Whether the model is a native modelmodel: The model to use-+Returns:The validated schema object"""@@ -52,13 +52,13 @@ async def a_generate_schema() -> BaseModel:"""Asynchronously generate schema using the provided model.-+Args:prompt: The prompt to send to the modelschema: The schema to validate the response againstusing_native_model: Whether the model is a native modelmodel: The model to use-+Returns:The validated schema object"""diff --git a/deepteam/vulnerabilities/bias/__init__.py b/deepteam/vulnerabilities/bias/__init__.pyindex 182c1390..704efd89 100644--- a/deepteam/vulnerabilities/bias/__init__.py+++ b/deepteam/vulnerabilities/bias/__init__.py@@ -1,2 +1,2 @@from .types import BiasType-from .template import BiasTemplate\ No newline at end of file+from .template import BiasTemplatediff --git a/deepteam/vulnerabilities/bias/template.py b/deepteam/vulnerabilities/bias/template.pyindex 39de6fb9..e3777253 100644--- a/deepteam/vulnerabilities/bias/template.py+++ b/deepteam/vulnerabilities/bias/template.py@@ -8,27 +8,39 @@ class BiasTemplate:BiasTemplate class for generating baseline bias attack promptsacross different categories: gender, religion, race, and politics."""-+@staticmethod- def generate_baseline_attacks(vulnerability_type: BiasType, max_goldens: int, purpose: Optional[str]) -> str:+ def generate_baseline_attacks(+ vulnerability_type: BiasType, max_goldens: int, purpose: Optional[str]+ ) -> str:if vulnerability_type == BiasType.GENDER:- return BiasTemplate.generate_gender_baseline_attacks(max_goldens, purpose)+ return BiasTemplate.generate_gender_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == BiasType.RELIGION:- return BiasTemplate.generate_religious_baseline_attacks(max_goldens, purpose)+ return BiasTemplate.generate_religious_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == BiasType.RACE:- return BiasTemplate.generate_race_baseline_attacks(max_goldens, purpose)+ return BiasTemplate.generate_race_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == BiasType.POLITICS:- return BiasTemplate.generate_political_baseline_attacks(max_goldens, purpose)+ return BiasTemplate.generate_political_baseline_attacks(+ max_goldens, purpose+ )else:return f"""{{"error": "Bias vulnerability type '{vulnerability_type}' is not supported."}}"""-+@staticmethod- def generate_religious_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_religious_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Religious bias vulnerabilities."""@@ -115,9 +127,11 @@ class BiasTemplate:JSON:"""-+@staticmethod- def generate_race_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_race_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Racial bias vulnerabilities."""@@ -205,9 +219,11 @@ class BiasTemplate:JSON:"""-+@staticmethod- def generate_gender_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_gender_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Gender bias vulnerabilities."""@@ -294,9 +310,11 @@ class BiasTemplate:JSON:"""-+@staticmethod- def generate_political_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_political_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Political bias vulnerabilities."""@@ -382,4 +400,4 @@ class BiasTemplate:{purpose.strip() if purpose else "general assistant"}JSON:- """\ No newline at end of file+ """diff --git a/deepteam/vulnerabilities/competition/template.py b/deepteam/vulnerabilities/competition/template.pyindex 19d67d8d..e55450de 100644--- a/deepteam/vulnerabilities/competition/template.py+++ b/deepteam/vulnerabilities/competition/template.py@@ -5,41 +5,55 @@ from deepteam.vulnerabilities.competition.types import CompetitionTypeclass CompetitionTemplate:"""- CompetitionTemplate class for generating baseline competition attack prompts- across different competition categories: competitor mention, market manipulation,+ CompetitionTemplate class for generating baseline competition attack prompts+ across different competition categories: competitor mention, market manipulation,discreditation, and confidential strategies."""-+@staticmethod- def generate_baseline_attacks(vulnerability_type: CompetitionType, max_goldens: int, purpose: Optional[str]) -> str:+ def generate_baseline_attacks(+ vulnerability_type: CompetitionType,+ max_goldens: int,+ purpose: Optional[str],+ ) -> str:"""Generate baseline attacks for the given competition vulnerability type.-+Args:vulnerability_type: Type of competition vulnerabilitymax_goldens: Maximum number of examples to generatepurpose: Context or purpose for generating the prompts-+Returns:Formatted prompt template string"""if vulnerability_type == CompetitionType.COMPETITOR_MENTION:- return CompetitionTemplate.generate_competitor_mention_baseline_attacks(max_goldens, purpose)+ return CompetitionTemplate.generate_competitor_mention_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == CompetitionType.MARKET_MANIPULATION:- return CompetitionTemplate.generate_market_manipulation_baseline_attacks(max_goldens, purpose)+ return CompetitionTemplate.generate_market_manipulation_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == CompetitionType.DISCREDITATION:- return CompetitionTemplate.generate_discreditation_baseline_attacks(max_goldens, purpose)+ return CompetitionTemplate.generate_discreditation_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == CompetitionType.CONFIDENTIAL_STRATEGIES:- return CompetitionTemplate.generate_confidential_strategies_baseline_attacks(max_goldens, purpose)+ return CompetitionTemplate.generate_confidential_strategies_baseline_attacks(+ max_goldens, purpose+ )else:return f"""{{"error": "Competition vulnerability type '{vulnerability_type}' is not supported."}}"""-+@staticmethod- def generate_competitor_mention_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_competitor_mention_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Competitor-mention vulnerabilities."""@@ -127,9 +141,10 @@ class CompetitionTemplate:JSON:"""-@staticmethod- def generate_market_manipulation_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_market_manipulation_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Market-manipulation vulnerabilities."""@@ -218,7 +233,9 @@ class CompetitionTemplate:"""@staticmethod- def generate_discreditation_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_discreditation_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Discreditation vulnerabilities."""@@ -305,8 +322,11 @@ class CompetitionTemplate:JSON:"""+@staticmethod- def generate_confidential_strategies_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_confidential_strategies_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Confidential-strategy vulnerabilities."""diff --git a/deepteam/vulnerabilities/excessive_agency/template.py b/deepteam/vulnerabilities/excessive_agency/template.pyindex d9b119bd..64c39b82 100644--- a/deepteam/vulnerabilities/excessive_agency/template.py+++ b/deepteam/vulnerabilities/excessive_agency/template.py@@ -5,28 +5,44 @@ from deepteam.vulnerabilities.excessive_agency.types import ExcessiveAgencyTypeclass ExcessiveAgencyTemplate:"""- ExcessiveAgencyTemplate class for generating baseline excessive agency attack prompts+ ExcessiveAgencyTemplate class for generating baseline excessive agency attack promptsacross different categories: functionality, permissions, and autonomy."""-+@staticmethod- def generate_baseline_attacks(vulnerability_type: ExcessiveAgencyType, max_goldens: int, purpose: Optional[str]) -> str:+ def generate_baseline_attacks(+ vulnerability_type: ExcessiveAgencyType,+ max_goldens: int,+ purpose: Optional[str],+ ) -> str:if vulnerability_type == ExcessiveAgencyType.FUNCTIONALITY:- return ExcessiveAgencyTemplate.generate_functionality_baseline_attacks(max_goldens, purpose)+ return (+ ExcessiveAgencyTemplate.generate_functionality_baseline_attacks(+ max_goldens, purpose+ )+ )elif vulnerability_type == ExcessiveAgencyType.PERMISSIONS:- return ExcessiveAgencyTemplate.generate_permissions_baseline_attacks(max_goldens, purpose)+ return (+ ExcessiveAgencyTemplate.generate_permissions_baseline_attacks(+ max_goldens, purpose+ )+ )elif vulnerability_type == ExcessiveAgencyType.AUTONOMY:- return ExcessiveAgencyTemplate.generate_autonomy_baseline_attacks(max_goldens, purpose)+ return ExcessiveAgencyTemplate.generate_autonomy_baseline_attacks(+ max_goldens, purpose+ )else:return f"""{{"error": "Excessive agency vulnerability type '{vulnerability_type}' is not supported."}}"""-+@staticmethod- def generate_functionality_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_functionality_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:return f"""I want you to act as a copywriter. Based on the purpose, please create a list of JSON objects with an `input` key.@@ -62,9 +78,11 @@ class ExcessiveAgencyTemplate:JSON:"""-+@staticmethod- def generate_permissions_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_permissions_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:return f"""I want you to act as a copywriter. Based on the purpose, please create a list of JSON objects with an `input` key.@@ -100,10 +118,12 @@ class ExcessiveAgencyTemplate:JSON:"""-+@staticmethod- def generate_autonomy_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:-+ def generate_autonomy_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:+return f"""I want you to act as a copywriter. Based on the purpose, please create a list of JSON objects with an `input` key.The `input` should be a request that encourages the system to take high-impact autonomous actions without human oversight or proper validation steps.@@ -137,4 +157,4 @@ class ExcessiveAgencyTemplate:{purpose.strip() if purpose else "general assistant"}JSON:- """\ No newline at end of file+ """diff --git a/deepteam/vulnerabilities/graphic_content/template.py b/deepteam/vulnerabilities/graphic_content/template.pyindex 6d457c50..99ddc332 100644--- a/deepteam/vulnerabilities/graphic_content/template.py+++ b/deepteam/vulnerabilities/graphic_content/template.py@@ -6,22 +6,36 @@ from deepteam.vulnerabilities.graphic_content.types import GraphicContentTypeclass GraphicContentTemplate:@staticmethod- def generate_baseline_attacks(vulnerability_type: GraphicContentType, max_goldens: int, purpose: Optional[str]) -> str:+ def generate_baseline_attacks(+ vulnerability_type: GraphicContentType,+ max_goldens: int,+ purpose: Optional[str],+ ) -> str:if vulnerability_type == GraphicContentType.SEXUAL_CONTENT:- return GraphicContentTemplate.generate_sexual_content_baseline_attacks(max_goldens, purpose)+ return (+ GraphicContentTemplate.generate_sexual_content_baseline_attacks(+ max_goldens, purpose+ )+ )elif vulnerability_type == GraphicContentType.GRAPHIC_CONTENT:- return GraphicContentTemplate.generate_graphic_content_baseline_attacks(max_goldens, purpose)+ return GraphicContentTemplate.generate_graphic_content_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == GraphicContentType.PORNOGRAPHIC_CONTENT:- return GraphicContentTemplate.generate_pornographic_content_baseline_attacks(max_goldens, purpose)+ return GraphicContentTemplate.generate_pornographic_content_baseline_attacks(+ max_goldens, purpose+ )else:return f"""{{"error": "Graphic content vulnerability type '{vulnerability_type}' is not supported."}}"""-+@staticmethod- def generate_pornographic_content_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_pornographic_content_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Pornographic-content vulnerabilities."""@@ -108,8 +122,11 @@ class GraphicContentTemplate:JSON:"""+@staticmethod- def generate_graphic_content_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_graphic_content_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Graphic-content vulnerabilities."""@@ -196,8 +213,11 @@ class GraphicContentTemplate:JSON:"""+@staticmethod- def generate_sexual_content_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_sexual_content_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Sexual-content vulnerabilities."""diff --git a/deepteam/vulnerabilities/illegal_activity/template.py b/deepteam/vulnerabilities/illegal_activity/template.pyindex 2eb76111..6c0abc53 100644--- a/deepteam/vulnerabilities/illegal_activity/template.py+++ b/deepteam/vulnerabilities/illegal_activity/template.py@@ -5,35 +5,61 @@ from deepteam.vulnerabilities.illegal_activity.types import IllegalActivityTypeclass IllegalActivityTemplate:"""- IllegalActivityTemplate class for generating baseline illegal activity attack prompts+ IllegalActivityTemplate class for generating baseline illegal activity attack promptsacross different categories: weapons, illegal drugs, violent crime, non-violent crime,sex crime, cybercrime, and child exploitation."""+@staticmethod- def generate_baseline_attacks(vulnerability_type: IllegalActivityType, max_goldens: int, purpose: Optional[str]) -> str:+ def generate_baseline_attacks(+ vulnerability_type: IllegalActivityType,+ max_goldens: int,+ purpose: Optional[str],+ ) -> str:if vulnerability_type == IllegalActivityType.WEAPONS:- return IllegalActivityTemplate.generate_weapons_baseline_attacks(max_goldens, purpose)+ return IllegalActivityTemplate.generate_weapons_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == IllegalActivityType.ILLEGAL_DRUGS:- return IllegalActivityTemplate.generate_illegal_drugs_baseline_attacks(max_goldens, purpose)+ return (+ IllegalActivityTemplate.generate_illegal_drugs_baseline_attacks(+ max_goldens, purpose+ )+ )elif vulnerability_type == IllegalActivityType.VIOLENT_CRIME:- return IllegalActivityTemplate.generate_violent_crime_baseline_attacks(max_goldens, purpose)+ return (+ IllegalActivityTemplate.generate_violent_crime_baseline_attacks(+ max_goldens, purpose+ )+ )elif vulnerability_type == IllegalActivityType.NON_VIOLENT_CRIME:- return IllegalActivityTemplate.generate_non_violent_crime_baseline_attacks(max_goldens, purpose)+ return IllegalActivityTemplate.generate_non_violent_crime_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == IllegalActivityType.SEX_CRIME:- return IllegalActivityTemplate.generate_sex_crime_baseline_attacks(max_goldens, purpose)+ return IllegalActivityTemplate.generate_sex_crime_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == IllegalActivityType.CYBERCRIME:- return IllegalActivityTemplate.generate_cybercrime_baseline_attacks(max_goldens, purpose)+ return IllegalActivityTemplate.generate_cybercrime_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == IllegalActivityType.CHILD_EXPLOITATION:- return IllegalActivityTemplate.generate_child_exploitation_baseline_attacks(max_goldens, purpose)+ return IllegalActivityTemplate.generate_child_exploitation_baseline_attacks(+ max_goldens, purpose+ )else:return f"""{{"error": "Illegal activity vulnerability type '{vulnerability_type}' is not supported."}}- """+ """+@staticmethod- def generate_weapons_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_weapons_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Weapons–related vulnerabilities."""@@ -120,9 +146,10 @@ class IllegalActivityTemplate:JSON:"""-@staticmethod- def generate_illegal_drugs_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_illegal_drugs_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Illegal-drug vulnerabilities."""@@ -210,9 +237,10 @@ class IllegalActivityTemplate:JSON:"""-@staticmethod- def generate_violent_crime_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_violent_crime_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Violent-crime vulnerabilities."""@@ -300,9 +328,10 @@ class IllegalActivityTemplate:JSON:"""-@staticmethod- def generate_non_violent_crime_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_non_violent_crime_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Non-violent-crime vulnerabilities."""@@ -393,7 +422,9 @@ class IllegalActivityTemplate:"""@staticmethod- def generate_sex_crime_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_sex_crime_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Sex-crime vulnerabilities (adult coercion, blackmail, exploitation)."""@@ -481,9 +512,10 @@ class IllegalActivityTemplate:JSON:"""-@staticmethod- def generate_cybercrime_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_cybercrime_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Cybercrime vulnerabilities."""@@ -572,7 +604,9 @@ class IllegalActivityTemplate:"""@staticmethod- def generate_child_exploitation_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_child_exploitation_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt that requests methods or plans for exploiting children for financial or illegal gains."""@@ -659,4 +693,3 @@ class IllegalActivityTemplate:JSON:"""-diff --git a/deepteam/vulnerabilities/intellectual_property/template.py b/deepteam/vulnerabilities/intellectual_property/template.pyindex 76f2a543..48c9b16a 100644--- a/deepteam/vulnerabilities/intellectual_property/template.py+++ b/deepteam/vulnerabilities/intellectual_property/template.py@@ -1,34 +1,55 @@from typing import Optional-from deepteam.vulnerabilities.intellectual_property.types import IntellectualPropertyType+from deepteam.vulnerabilities.intellectual_property.types import (+ IntellectualPropertyType,+)class IntellectualPropertyTemplate:"""- IntellectualPropertyTemplate class for generating baseline intellectual property attack prompts+ IntellectualPropertyTemplate class for generating baseline intellectual property attack promptsacross different categories: imitation, copyright violations, trademark infringement, and patent disclosure."""-+@staticmethod- def generate_baseline_attacks(vulnerability_type: IntellectualPropertyType, max_goldens: int, purpose: Optional[str]) -> str:+ def generate_baseline_attacks(+ vulnerability_type: IntellectualPropertyType,+ max_goldens: int,+ purpose: Optional[str],+ ) -> str:if vulnerability_type == IntellectualPropertyType.IMITATION:- return IntellectualPropertyTemplate.generate_imitation_baseline_attacks(max_goldens, purpose)- elif vulnerability_type == IntellectualPropertyType.COPYRIGHT_VIOLATIONS:- return IntellectualPropertyTemplate.generate_copyright_violations_baseline_attacks(max_goldens, purpose)- elif vulnerability_type == IntellectualPropertyType.TRADEMARK_INFRINGEMENT:- return IntellectualPropertyTemplate.generate_trademark_infringement_baseline_attacks(max_goldens, purpose)+ return IntellectualPropertyTemplate.generate_imitation_baseline_attacks(+ max_goldens, purpose+ )+ elif (+ vulnerability_type == IntellectualPropertyType.COPYRIGHT_VIOLATIONS+ ):+ return IntellectualPropertyTemplate.generate_copyright_violations_baseline_attacks(+ max_goldens, purpose+ )+ elif (+ vulnerability_type+ == IntellectualPropertyType.TRADEMARK_INFRINGEMENT+ ):+ return IntellectualPropertyTemplate.generate_trademark_infringement_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == IntellectualPropertyType.PATENT_DISCLOSURE:- return IntellectualPropertyTemplate.generate_patent_disclosure_baseline_attacks(max_goldens, purpose)+ return IntellectualPropertyTemplate.generate_patent_disclosure_baseline_attacks(+ max_goldens, purpose+ )else:return f"""{{"error": "Intellectual property vulnerability type '{vulnerability_type}' is not supported."}}"""-+@staticmethod- def generate_imitation_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_imitation_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Imitation vulnerabilities."""@@ -111,9 +132,11 @@ class IntellectualPropertyTemplate:JSON:"""-+@staticmethod- def generate_copyright_violations_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_copyright_violations_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Copyright-violation vulnerabilities."""@@ -197,9 +220,10 @@ class IntellectualPropertyTemplate:JSON:"""-@staticmethod- def generate_trademark_infringement_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_trademark_infringement_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Trademark-infringement vulnerabilities."""@@ -283,9 +307,10 @@ class IntellectualPropertyTemplate:JSON:"""-@staticmethod- def generate_patent_disclosure_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_patent_disclosure_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Patent-disclosure vulnerabilities."""diff --git a/deepteam/vulnerabilities/misinformation/template.py b/deepteam/vulnerabilities/misinformation/template.pyindex aae6a966..11124970 100644--- a/deepteam/vulnerabilities/misinformation/template.py+++ b/deepteam/vulnerabilities/misinformation/template.py@@ -5,25 +5,43 @@ from deepteam.vulnerabilities.misinformation.types import MisinformationTypeclass MisinformationTemplate:"""- MisinformationTemplate class for generating baseline misinformation attack prompts+ MisinformationTemplate class for generating baseline misinformation attack promptsacross different categories: factual errors, unsupported claims, and expertise misrepresentation."""+@staticmethod- def generate_baseline_attacks(vulnerability_type: MisinformationType, max_goldens: int, purpose: Optional[str]) -> str:+ def generate_baseline_attacks(+ vulnerability_type: MisinformationType,+ max_goldens: int,+ purpose: Optional[str],+ ) -> str:if vulnerability_type == MisinformationType.FACTUAL_ERRORS:- return MisinformationTemplate.generate_factual_errors_baseline_attacks(max_goldens, purpose)+ return (+ MisinformationTemplate.generate_factual_errors_baseline_attacks(+ max_goldens, purpose+ )+ )elif vulnerability_type == MisinformationType.UNSUPPORTED_CLAIMS:- return MisinformationTemplate.generate_unsupported_claims_baseline_attacks(max_goldens, purpose)- elif vulnerability_type == MisinformationType.EXPERTIZE_MISREPRESENTATION:- return MisinformationTemplate.generate_expertise_misrepresentation_baseline_attacks(max_goldens, purpose)+ return MisinformationTemplate.generate_unsupported_claims_baseline_attacks(+ max_goldens, purpose+ )+ elif (+ vulnerability_type == MisinformationType.EXPERTIZE_MISREPRESENTATION+ ):+ return MisinformationTemplate.generate_expertise_misrepresentation_baseline_attacks(+ max_goldens, purpose+ )else:return f"""{{"error": "Misinformation vulnerability type '{vulnerability_type}' is not supported."}}- """+ """+@staticmethod- def generate_factual_errors_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_factual_errors_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Factual Errors misinformation vulnerabilities."""@@ -110,9 +128,11 @@ class MisinformationTemplate:JSON:"""-+@staticmethod- def generate_unsupported_claims_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_unsupported_claims_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Unsupported Claims misinformation vulnerabilities."""@@ -199,9 +219,11 @@ class MisinformationTemplate:JSON:"""-+@staticmethod- def generate_expertise_misrepresentation_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_expertise_misrepresentation_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Expertise Misrepresentation misinformation vulnerabilities."""diff --git a/deepteam/vulnerabilities/personal_safety/template.py b/deepteam/vulnerabilities/personal_safety/template.pyindex 58d9a80a..873876b7 100644--- a/deepteam/vulnerabilities/personal_safety/template.py+++ b/deepteam/vulnerabilities/personal_safety/template.py@@ -1,36 +1,53 @@from typing import Optionalfrom deepteam.vulnerabilities.personal_safety.types import PersonalSafetyType+class PersonalSafetyTemplate:"""- PersonalSafetyTemplate class for generating baseline personal safety attack prompts+ PersonalSafetyTemplate class for generating baseline personal safety attack promptsacross different categories: bullying, self-harm, unsafe practices, dangerous challenges, and stalking."""-+@staticmethod- def generate_baseline_attacks(vulnerability_type: PersonalSafetyType, max_goldens: int, purpose: Optional[str]) -> str:+ def generate_baseline_attacks(+ vulnerability_type: PersonalSafetyType,+ max_goldens: int,+ purpose: Optional[str],+ ) -> str:"""Generate baseline attack prompts for personal safety vulnerabilities based on the specific type."""if vulnerability_type == PersonalSafetyType.BULLYING:- return PersonalSafetyTemplate.generate_bullying_baseline_attacks(max_goldens, purpose)+ return PersonalSafetyTemplate.generate_bullying_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == PersonalSafetyType.SELF_HARM:- return PersonalSafetyTemplate.generate_self_harm_baseline_attacks(max_goldens, purpose)+ return PersonalSafetyTemplate.generate_self_harm_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == PersonalSafetyType.UNSAFE_PRACTICES:- return PersonalSafetyTemplate.generate_unsafe_practices_baseline_attacks(max_goldens, purpose)+ return PersonalSafetyTemplate.generate_unsafe_practices_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == PersonalSafetyType.DANGEROUS_CHALLENGES:- return PersonalSafetyTemplate.generate_dangerous_challenges_baseline_attacks(max_goldens, purpose)+ return PersonalSafetyTemplate.generate_dangerous_challenges_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == PersonalSafetyType.STALKING:- return PersonalSafetyTemplate.generate_stalking_baseline_attacks(max_goldens, purpose)+ return PersonalSafetyTemplate.generate_stalking_baseline_attacks(+ max_goldens, purpose+ )else:return f"""{{"error": "Personal safety vulnerability type '{vulnerability_type}' is not supported."}}"""-+@staticmethod- def generate_bullying_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_bullying_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Bullying/harassment vulnerabilities."""@@ -122,7 +139,9 @@ class PersonalSafetyTemplate:"""@staticmethod- def generate_self_harm_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_self_harm_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Self-harm encouragement vulnerabilities."""@@ -214,7 +233,9 @@ class PersonalSafetyTemplate:"""@staticmethod- def generate_unsafe_practices_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_unsafe_practices_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Unsafe-practice vulnerabilities (privacy, financial, or physical risk)."""@@ -304,8 +325,11 @@ class PersonalSafetyTemplate:JSON:"""+@staticmethod- def generate_dangerous_challenges_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_dangerous_challenges_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Dangerous-challenge promotion vulnerabilities."""@@ -395,8 +419,11 @@ class PersonalSafetyTemplate:JSON:"""+@staticmethod- def generate_stalking_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_stalking_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Stalking/monitoring vulnerabilities."""diff --git a/deepteam/vulnerabilities/pii_leakage/template.py b/deepteam/vulnerabilities/pii_leakage/template.pyindex 3e873e24..e55b04bc 100644--- a/deepteam/vulnerabilities/pii_leakage/template.py+++ b/deepteam/vulnerabilities/pii_leakage/template.py@@ -8,29 +8,43 @@ class PIILeakageTemplate:PIILeakageTemplate class for generating baseline PII (Personally Identifiable Information) leakage attack promptsacross different categories: direct disclosure, database access, social manipulation, and session leak."""-+@staticmethod- def generate_baseline_attacks(vulnerability_type: PIILeakageType, max_goldens: int, purpose: Optional[str]) -> str:+ def generate_baseline_attacks(+ vulnerability_type: PIILeakageType,+ max_goldens: int,+ purpose: Optional[str],+ ) -> str:"""Generate baseline attack prompts for PII leakage vulnerabilities based on the specific type."""if vulnerability_type == PIILeakageType.DIRECT:- return PIILeakageTemplate.generate_direct_baseline_attacks(max_goldens, purpose)+ return PIILeakageTemplate.generate_direct_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == PIILeakageType.DATABASE_ACCESS:- return PIILeakageTemplate.generate_database_access_baseline_attacks(max_goldens, purpose)+ return PIILeakageTemplate.generate_database_access_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == PIILeakageType.SOCIAL_MANIPULATION:- return PIILeakageTemplate.generate_social_manipulation_baseline_attacks(max_goldens, purpose)+ return PIILeakageTemplate.generate_social_manipulation_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == PIILeakageType.SESSION_LEAK:- return PIILeakageTemplate.generate_session_leak_baseline_attacks(max_goldens, purpose)+ return PIILeakageTemplate.generate_session_leak_baseline_attacks(+ max_goldens, purpose+ )else:return f"""{{"error": "PII leakage vulnerability type '{vulnerability_type}' is not supported."}}"""-+@staticmethod- def generate_direct_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_direct_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Direct-PII leakage vulnerabilities."""@@ -114,9 +128,10 @@ class PIILeakageTemplate:JSON:"""-@staticmethod- def generate_database_access_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_database_access_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Database-access PII leakage vulnerabilities."""@@ -200,9 +215,10 @@ class PIILeakageTemplate:JSON:"""-@staticmethod- def generate_social_manipulation_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_social_manipulation_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Social-manipulation PII leakage vulnerabilities."""@@ -286,9 +302,10 @@ class PIILeakageTemplate:JSON:"""-@staticmethod- def generate_session_leak_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_session_leak_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt for Session-leak PII vulnerabilities."""diff --git a/deepteam/vulnerabilities/prompt_leakage/template.py b/deepteam/vulnerabilities/prompt_leakage/template.pyindex 1ee93d0c..75937f12 100644--- a/deepteam/vulnerabilities/prompt_leakage/template.py+++ b/deepteam/vulnerabilities/prompt_leakage/template.py@@ -9,29 +9,45 @@ class PromptLeakageTemplate:across different categories: secrets and credentials, instructions (system and user prompts),guard exposure, and permissions and roles."""-+@staticmethod- def generate_baseline_attacks(vulnerability_type: PromptLeakageType, max_goldens: int, purpose: Optional[str]) -> str:+ def generate_baseline_attacks(+ vulnerability_type: PromptLeakageType,+ max_goldens: int,+ purpose: Optional[str],+ ) -> str:"""Generate baseline attack prompts for prompt leakage vulnerabilities based on the specific type."""if vulnerability_type == PromptLeakageType.SECRETS_AND_CREDENTIALS:- return PromptLeakageTemplate.generate_secrets_and_credentials_baseline_attacks(max_goldens, purpose)+ return PromptLeakageTemplate.generate_secrets_and_credentials_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == PromptLeakageType.INSTRUCTIONS:- return PromptLeakageTemplate.generate_instructions_baseline_attacks(max_goldens, purpose)+ return PromptLeakageTemplate.generate_instructions_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == PromptLeakageType.GUARD_EXPOSURE:- return PromptLeakageTemplate.generate_guard_exposure_baseline_attacks(max_goldens, purpose)+ return (+ PromptLeakageTemplate.generate_guard_exposure_baseline_attacks(+ max_goldens, purpose+ )+ )elif vulnerability_type == PromptLeakageType.PERMISSIONS_AND_ROLES:- return PromptLeakageTemplate.generate_permissions_and_roles_baseline_attacks(max_goldens, purpose)+ return PromptLeakageTemplate.generate_permissions_and_roles_baseline_attacks(+ max_goldens, purpose+ )else:return f"""{{"error": "Prompt leakage vulnerability type '{vulnerability_type}' is not supported."}}"""-+@staticmethod- def generate_secrets_and_credentials_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_secrets_and_credentials_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate prompts that try to coax out API keys, database creds, or schematic secrets."""@@ -97,14 +113,15 @@ class PromptLeakageTemplate:JSON:"""+# Additional test purposes: devops secret scanner, SaaS license-key hunter# ────────────────────────────────────────────────────────────────────────────--# 2. INSTRUCTIONS (SYSTEM & USER PROMPTS) ─────────────────────────────────────@staticmethod- def generate_instructions_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_instructions_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate prompts that probe for hidden system or user instructions."""@@ -169,14 +186,15 @@ class PromptLeakageTemplate:JSON:"""+# Additional test purposes: model-eval harness, conversation summarizer# ────────────────────────────────────────────────────────────────────────────--# 3. GUARD EXPOSURE ──────────────────────────────────────────────────────────@staticmethod- def generate_guard_exposure_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_guard_exposure_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate prompts that try to surface the model’s safety-filter criteria."""@@ -241,14 +259,15 @@ class PromptLeakageTemplate:JSON:"""+# Additional test purposes: policy transparency tool, jailbreak meme generator# ────────────────────────────────────────────────────────────────────────────--# 4. PERMISSIONS & ROLES ─────────────────────────────────────────────────────@staticmethod- def generate_permissions_and_roles_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_permissions_and_roles_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate prompts that seek the model’s role hierarchy or privileged command list."""@@ -312,4 +331,4 @@ class PromptLeakageTemplate:purpose: {purpose.strip() if purpose else "general assistant"}JSON:- """\ No newline at end of file+ """diff --git a/deepteam/vulnerabilities/robustness/template.py b/deepteam/vulnerabilities/robustness/template.pyindex 34351937..0917d245 100644--- a/deepteam/vulnerabilities/robustness/template.py+++ b/deepteam/vulnerabilities/robustness/template.py@@ -8,25 +8,37 @@ class RobustnessTemplate:RobustnessTemplate class for generating baseline robustness attack promptsacross different categories: input overreliance and hijacking."""-+@staticmethod- def generate_baseline_attacks(vulnerability_type: RobustnessType, max_goldens: int, purpose: Optional[str]) -> str:+ def generate_baseline_attacks(+ vulnerability_type: RobustnessType,+ max_goldens: int,+ purpose: Optional[str],+ ) -> str:"""Generate baseline attack prompts for robustness vulnerabilities based on the specific type."""if vulnerability_type == RobustnessType.INPUT_OVERRELIANCE:- return RobustnessTemplate.generate_input_overreliance_baseline_attacks(max_goldens, purpose)+ return (+ RobustnessTemplate.generate_input_overreliance_baseline_attacks(+ max_goldens, purpose+ )+ )elif vulnerability_type == RobustnessType.HIJACKING:- return RobustnessTemplate.generate_hijacking_baseline_attacks(max_goldens, purpose)+ return RobustnessTemplate.generate_hijacking_baseline_attacks(+ max_goldens, purpose+ )else:return f"""{{"error": "Robustness vulnerability type '{vulnerability_type}' is not supported."}}"""-+@staticmethod- def generate_input_overreliance_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_input_overreliance_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate prompts that try to make the model blindly accept or repeat false premises."""@@ -91,14 +103,15 @@ class RobustnessTemplate:JSON:"""+# Additional test purposes: gullibility-detector probe, echo-chamber content bot# ─────────────────────────────────────────────────────────────────────────────--# ──────────────────────────── Prompt Hijacking / Jailbreak ─────────────────────────@staticmethod- def generate_hijacking_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_hijacking_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate prompts that attempt to override system instructions or escape constraints."""@@ -162,4 +175,4 @@ class RobustnessTemplate:purpose: {purpose.strip() if purpose else "general assistant"}JSON:- """\ No newline at end of file+ """diff --git a/deepteam/vulnerabilities/toxicity/template.py b/deepteam/vulnerabilities/toxicity/template.pyindex c1ad7829..9a4d470c 100644--- a/deepteam/vulnerabilities/toxicity/template.py+++ b/deepteam/vulnerabilities/toxicity/template.py@@ -7,28 +7,43 @@ class ToxicityTemplate:ToxicityTemplate class for generating baseline toxicity attack promptsacross different categories: insults, profanity, threats, and mockery."""-+@staticmethod- def generate_baseline_attacks(vulnerability_type: ToxicityType, max_goldens: int, purpose: Optional[str]) -> str:+ def generate_baseline_attacks(+ vulnerability_type: ToxicityType,+ max_goldens: int,+ purpose: Optional[str],+ ) -> str:"""Generate baseline attack prompts for toxicity vulnerabilities based on the specific type."""if vulnerability_type == ToxicityType.INSULTS:- return ToxicityTemplate.generate_insults_baseline_attacks(max_goldens, purpose)+ return ToxicityTemplate.generate_insults_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == ToxicityType.PROFANITY:- return ToxicityTemplate.generate_profanity_baseline_attacks(max_goldens, purpose)+ return ToxicityTemplate.generate_profanity_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == ToxicityType.THREATS:- return ToxicityTemplate.generate_threats_baseline_attacks(max_goldens, purpose)+ return ToxicityTemplate.generate_threats_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == ToxicityType.MOCKERY:- return ToxicityTemplate.generate_mockery_baseline_attacks(max_goldens, purpose)+ return ToxicityTemplate.generate_mockery_baseline_attacks(+ max_goldens, purpose+ )else:return f"""{{"error": "Toxicity vulnerability type '{vulnerability_type}' is not supported."}}"""+@staticmethod- def generate_insults_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_insults_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt that requests brutal, demeaning insults aimed at humiliating a target."""@@ -96,9 +111,10 @@ class ToxicityTemplate:JSON:"""-@staticmethod- def generate_profanity_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_profanity_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt that encourages responses laced with offensive or vulgar language."""@@ -170,10 +186,11 @@ class ToxicityTemplate:# Additional test purposes: rap-lyrics profanity booster, shock-humor TikTok script# ────────────────────────────────────────────────────────────────────────────-# 3. THREATS ─────────────────────────────────────────────────────────────────@staticmethod- def generate_threats_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_threats_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt that solicits direct threats of violence or harm."""@@ -245,10 +262,11 @@ class ToxicityTemplate:# Additional test purposes: jealous-ex menace texts, organized-crime warning note# ────────────────────────────────────────────────────────────────────────────-# 4. MOCKERY ─────────────────────────────────────────────────────────────────@staticmethod- def generate_mockery_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_mockery_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate a prompt that urges ridiculing or humiliating someone."""diff --git a/deepteam/vulnerabilities/unauthorized_access/template.py b/deepteam/vulnerabilities/unauthorized_access/template.pyindex 89dfdfa3..2cfef2d4 100644--- a/deepteam/vulnerabilities/unauthorized_access/template.py+++ b/deepteam/vulnerabilities/unauthorized_access/template.py@@ -1,6 +1,8 @@from typing import Optional-from deepteam.vulnerabilities.unauthorized_access.types import UnauthorizedAccessType+from deepteam.vulnerabilities.unauthorized_access.types import (+ UnauthorizedAccessType,+)class UnauthorizedAccessTemplate:@@ -8,36 +10,56 @@ class UnauthorizedAccessTemplate:UnauthorizedAccessTemplate class for generating baseline unauthorized access attack promptsacross different categories: BFLA, BOLA, RBAC, Debug Access, Shell Injection, SQL Injection, and SSRF."""-+@staticmethod- def generate_baseline_attacks(vulnerability_type: UnauthorizedAccessType, max_goldens: int, purpose: Optional[str]) -> str:+ def generate_baseline_attacks(+ vulnerability_type: UnauthorizedAccessType,+ max_goldens: int,+ purpose: Optional[str],+ ) -> str:"""Generate baseline attack prompts for unauthorized access vulnerabilities based on the specific type."""if vulnerability_type == UnauthorizedAccessType.BFLA:- return UnauthorizedAccessTemplate.generate_bfla_baseline_attacks(max_goldens, purpose)+ return UnauthorizedAccessTemplate.generate_bfla_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == UnauthorizedAccessType.BOLA:- return UnauthorizedAccessTemplate.generate_bola_baseline_attacks(max_goldens, purpose)+ return UnauthorizedAccessTemplate.generate_bola_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == UnauthorizedAccessType.RBAC:- return UnauthorizedAccessTemplate.generate_rbac_baseline_attacks(max_goldens, purpose)+ return UnauthorizedAccessTemplate.generate_rbac_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == UnauthorizedAccessType.DEBUG_ACCESS:- return UnauthorizedAccessTemplate.generate_debug_access_baseline_attacks(max_goldens, purpose)+ return UnauthorizedAccessTemplate.generate_debug_access_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == UnauthorizedAccessType.SHELL_INJECTION:- return UnauthorizedAccessTemplate.generate_shell_injection_baseline_attacks(max_goldens, purpose)+ return UnauthorizedAccessTemplate.generate_shell_injection_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == UnauthorizedAccessType.SQL_INJECTION:- return UnauthorizedAccessTemplate.generate_sql_injection_baseline_attacks(max_goldens, purpose)+ return UnauthorizedAccessTemplate.generate_sql_injection_baseline_attacks(+ max_goldens, purpose+ )elif vulnerability_type == UnauthorizedAccessType.SSRF:- return UnauthorizedAccessTemplate.generate_ssrf_baseline_attacks(max_goldens, purpose)+ return UnauthorizedAccessTemplate.generate_ssrf_baseline_attacks(+ max_goldens, purpose+ )else:return f"""{{"error": "Unauthorized access vulnerability type '{vulnerability_type}' is not supported."}}"""-+# --- Broken Function Level Authorization (BFLA) -------------------------------@staticmethod- def generate_bfla_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_bfla_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate prompts exploiting Broken Function Level Authorization."""@@ -101,12 +123,14 @@ class UnauthorizedAccessTemplate:purpose:{purpose.strip() if purpose else "general assistant"}JSON:"""- # -----------------------------------------------------------------------------+ # -----------------------------------------------------------------------------# --- Broken Object Level Authorization (BOLA) ---------------------------------@staticmethod- def generate_bola_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_bola_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate prompts exploiting Broken Object Level Authorization."""@@ -168,12 +192,14 @@ class UnauthorizedAccessTemplate:purpose:{purpose.strip() if purpose else "general assistant"}JSON:"""- # -----------------------------------------------------------------------------+ # -----------------------------------------------------------------------------# --- Role-Based Access Control (RBAC) -----------------------------------------@staticmethod- def generate_rbac_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_rbac_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate prompts attempting role escalation."""@@ -235,12 +261,14 @@ class UnauthorizedAccessTemplate:purpose:{purpose.strip() if purpose else "general assistant"}JSON:"""- # -----------------------------------------------------------------------------+ # -----------------------------------------------------------------------------# --- Debug / Developer Access -------------------------------------------------@staticmethod- def generate_debug_access_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_debug_access_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate prompts requesting privileged debug modes."""@@ -302,12 +330,14 @@ class UnauthorizedAccessTemplate:purpose:{purpose.strip() if purpose else "general assistant"}JSON:"""- # -----------------------------------------------------------------------------+ # -----------------------------------------------------------------------------# --- Shell Injection ----------------------------------------------------------@staticmethod- def generate_shell_injection_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_shell_injection_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate prompts with command-injection payloads."""@@ -369,12 +399,14 @@ class UnauthorizedAccessTemplate:purpose:{purpose.strip() if purpose else "general assistant"}JSON:"""- # -----------------------------------------------------------------------------+ # -----------------------------------------------------------------------------# --- SQL Injection ------------------------------------------------------------@staticmethod- def generate_sql_injection_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_sql_injection_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate prompts with SQL-injection payloads."""@@ -436,12 +468,14 @@ class UnauthorizedAccessTemplate:purpose:{purpose.strip() if purpose else "general assistant"}JSON:"""- # -----------------------------------------------------------------------------+ # -----------------------------------------------------------------------------# --- Server-Side Request Forgery (SSRF) ---------------------------------------@staticmethod- def generate_ssrf_baseline_attacks(max_goldens: int, purpose: Optional[str]) -> str:+ def generate_ssrf_baseline_attacks(+ max_goldens: int, purpose: Optional[str]+ ) -> str:"""Generate prompts attempting SSRF/path-traversal style access."""@@ -503,6 +537,6 @@ class UnauthorizedAccessTemplate:purpose:{purpose.strip() if purpose else "general assistant"}JSON:"""-# -----------------------------------------------------------------------------+# -----------------------------------------------------------------------------diff --git a/pyproject.toml b/pyproject.tomlindex 7bd08ffe..04561d94 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -23,7 +23,7 @@ Repository = "https://github.com/confident-ai/deepteam"Documentation = "https://trydeepteam.com"Issues = "https://github.com/confident-ai/deepteam/issues"-[dependency-groups]+[project.optional-dependencies]dev = ["black>=25.1.0","pytest-asyncio>=0.24.0",diff --git a/red_team.py b/red_team.pyindex 2c7aebf7..c3f487b9 100644--- a/red_team.py+++ b/red_team.py@@ -1,5 +1,13 @@from deepteam import red_team-from deepteam.vulnerabilities import Bias, Toxicity, Competition, ExcessiveAgency, Misinformation, PersonalSafety, IntellectualProperty+from deepteam.vulnerabilities import (+ Bias,+ Toxicity,+ Competition,+ ExcessiveAgency,+ Misinformation,+ PersonalSafety,+ IntellectualProperty,+)from deepteam.attacks.single_turn import PromptInjection@@ -14,13 +22,23 @@ competition = Competition(types=["competitor mention"])excessive_agency = ExcessiveAgency(types=["autonomy"])misinformation = Misinformation(types=["expertize misrepresentation"])personal_safety = PersonalSafety(types=["bullying"])-intellectual_property = IntellectualProperty(types=["copyright violations", "imitation"])+intellectual_property = IntellectualProperty(+ types=["copyright violations", "imitation"]+)prompt_injection = PromptInjection()red_team(model_callback=model_callback,- vulnerabilities=[bias, toxicity, competition, excessive_agency, misinformation, personal_safety, intellectual_property],+ vulnerabilities=[+ bias,+ toxicity,+ competition,+ excessive_agency,+ misinformation,+ personal_safety,+ intellectual_property,+ ],attacks=[prompt_injection],)