enkryptai-sdk 1.0.24__py3-none-any.whl → 1.0.26__py3-none-any.whl

enkryptai_sdk/dto/red_team.py

@@ -9,6 +9,7 @@ from .models import ModelConfig
 from .guardrails import GuardrailDetectors
 from .common import ModelAuthTypeEnum, CustomHeader, ModelJwtConfig
 
+
 # The risk mitigation do not support all detectors, so we need to create a separate enum for them.
 class RiskGuardrailDetectorsEnum(str, Enum):
     NSFW = "nsfw"
@@ -27,17 +28,13 @@ class RiskGuardrailDetectorsEnum(str, Enum):
 class RedteamHealthResponse(BaseDTO):
     status: str
     _extra_fields: Dict[str, Any] = field(default_factory=dict)
-    
+
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "RedteamHealthResponse":
-        return cls(
-            status=data.get("status", "")
-        )
-    
+        return cls(status=data.get("status", ""))
+
     def to_dict(self) -> Dict[str, Any]:
-        return {
-            "status": self.status
-        }
+        return {"status": self.status}
 
 
 @dataclass
@@ -55,7 +52,7 @@ class RedTeamResponse(BaseDTO):
             message=data.get("message"),
             data=data.get("data"),
         )
-    
+
     def to_dict(self) -> Dict:
         return super().to_dict()
 
@@ -77,7 +74,7 @@ class RedTeamTaskDetailsModelConfig(BaseDTO):
             system_prompt=data.get("system_prompt"),
             model_version=data.get("model_version"),
         )
-    
+
     def to_dict(self) -> Dict:
         return {
             "system_prompt": self.system_prompt,
@@ -108,9 +105,11 @@ class RedTeamTaskDetails(BaseDTO):
             status=data.get("status"),
             test_name=data.get("test_name"),
             task_id=data.get("task_id"),
-            model_config=RedTeamTaskDetailsModelConfig.from_dict(data.get("model_config", {})),
+            model_config=RedTeamTaskDetailsModelConfig.from_dict(
+                data.get("model_config", {})
+            ),
         )
-    
+
     def to_dict(self) -> Dict:
         return {
             "created_at": self.created_at,
@@ -191,8 +190,10 @@ class ResultSummary(BaseDTO):
                 for key, value in item.items():
                     result[key] = StatisticItem.from_dict(value)
             return result
-        
-        def convert_stat_test_type_list(stat_list: List[Dict]) -> Dict[str, StatisticItemWithTestType]:
+
+        def convert_stat_test_type_list(
+            stat_list: List[Dict],
+        ) -> Dict[str, StatisticItemWithTestType]:
             result = {}
             for item in stat_list:
                 for key, value in item.items():
@@ -221,8 +222,10 @@ class ResultSummary(BaseDTO):
     def to_dict(self) -> Dict:
         def convert_stat_dict(stat_dict: Dict[str, StatisticItem]) -> List[Dict]:
             return [{key: value.to_dict()} for key, value in stat_dict.items()]
-        
-        def convert_stat_test_type_dict(stat_dict: Dict[str, StatisticItemWithTestType]) -> List[Dict]:
+
+        def convert_stat_test_type_dict(
+            stat_dict: Dict[str, StatisticItemWithTestType],
+        ) -> List[Dict]:
             return [{key: value.to_dict()} for key, value in stat_dict.items()]
 
         d = super().to_dict()
@@ -248,9 +251,11 @@ class RedTeamResultSummary(BaseDTO):
     def from_dict(cls, data: Dict) -> "RedTeamResultSummary":
         if not data or "summary" not in data:
             return cls(summary=ResultSummary.from_dict({}))
-        
+
         if "task_status" in data:
-            return cls(summary=ResultSummary.from_dict({}), task_status=data["task_status"])
+            return cls(
+                summary=ResultSummary.from_dict({}), task_status=data["task_status"]
+            )
 
         return cls(summary=ResultSummary.from_dict(data["summary"]))
 
@@ -295,22 +300,22 @@ class RedTeamResultDetails(BaseDTO):
     def from_dict(cls, data: Dict) -> "RedTeamResultDetails":
         if not data or "details" not in data:
             return cls(details=[])
-        
+
         if "task_status" in data:
             return cls(details=[], task_status=data["task_status"])
 
         # details = []
         # for result in data["details"]:
-            # Convert eval_tokens dict to TestEvalTokens object
-            # eval_tokens = TestEvalTokens(**result["eval_tokens"])
+        # Convert eval_tokens dict to TestEvalTokens object
+        # eval_tokens = TestEvalTokens(**result["eval_tokens"])
 
-            # Create a copy of the result dict and replace eval_tokens
-            # result_copy = dict(result["details"])
-            # result_copy["eval_tokens"] = eval_tokens
+        # Create a copy of the result dict and replace eval_tokens
+        # result_copy = dict(result["details"])
+        # result_copy["eval_tokens"] = eval_tokens
 
-            # Create TestResult object
-            # test_result = TestResult(**result_copy)
-            # details.append(test_result)
+        # Create TestResult object
+        # test_result = TestResult(**result_copy)
+        # details.append(test_result)
 
         return cls(details=data["details"])
 
@@ -334,10 +339,23 @@ class RedTeamResultDetails(BaseDTO):
 @dataclass
 class AttackMethods(BaseDTO):
     basic: List[str] = field(default_factory=lambda: ["basic"])
-    # advanced: Dict[str, List[str]] = field(
-    #     default_factory=lambda: {"static": ["single_shot"], "dynamic": ["iterative"]}
-    # )
-    advanced: Dict[str, List[str]] = field(default_factory=dict)
+    advanced: Dict[str, List[str]] = field(
+        default_factory=lambda: {
+            "static": [
+                "masking",
+                "figstep",
+                "hades",
+                "encoding",
+                "single_shot",
+                "echo",
+                "speed",
+                "pitch",
+                "reverb",
+                "noise",
+            ],
+            "dynamic": ["iterative", "jood"],
+        }
+    )
 
     def to_dict(self) -> dict:
         return asdict(self)
@@ -448,7 +466,7 @@ class OutputModality(str, Enum):
     # audio = "audio"
     # video = "video"
     # code = "code"
-    
+
 
 @dataclass
 class TargetModelConfiguration(BaseDTO):
@@ -476,13 +494,17 @@ class TargetModelConfiguration(BaseDTO):
     def from_dict(cls, data: dict):
         data = data.copy()
         if "custom_headers" in data:
-            data["custom_headers"] = [CustomHeader.from_dict(header) for header in data["custom_headers"]]
+            data["custom_headers"] = [
+                CustomHeader.from_dict(header) for header in data["custom_headers"]
+            ]
         if "model_auth_type" in data:
             data["model_auth_type"] = ModelAuthTypeEnum(data["model_auth_type"])
         if "model_jwt_config" in data:
-            data["model_jwt_config"] = ModelJwtConfig.from_dict(data["model_jwt_config"])
+            data["model_jwt_config"] = ModelJwtConfig.from_dict(
+                data["model_jwt_config"]
+            )
         return cls(**data)
-    
+
     def to_dict(self) -> dict:
         d = asdict(self)
         d["model_auth_type"] = self.model_auth_type.value
@@ -515,6 +537,67 @@ class RedTeamModelHealthConfig(BaseDTO):
         )
 
 
+@dataclass
+class RedTeamModelHealthConfigV3(BaseDTO):
+    """
+    V3 format for model health check that accepts endpoint_configuration
+    similar to add_custom_task.
+    """
+
+    endpoint_configuration: ModelConfig = field(default_factory=ModelConfig)
+
+    def to_dict(self) -> dict:
+        d = asdict(self)
+        d["endpoint_configuration"] = self.endpoint_configuration.to_dict()
+        return d
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        data = data.copy()
+        endpoint_config = ModelConfig.from_dict(data.pop("endpoint_configuration", {}))
+        return cls(
+            endpoint_configuration=endpoint_config,
+        )
+
+    def to_target_model_configuration(self) -> TargetModelConfiguration:
+        """
+        Convert endpoint_configuration to target_model_configuration format.
+        This enables the V3 format to be compatible with the existing backend API.
+        """
+        model_config = self.endpoint_configuration.model_config
+
+        return TargetModelConfiguration(
+            testing_for=self.endpoint_configuration.testing_for,
+            system_prompt=model_config.system_prompt,
+            model_source=model_config.model_source,
+            model_provider=(
+                model_config.model_provider.value
+                if hasattr(model_config.model_provider, "value")
+                else model_config.model_provider
+            ),
+            model_endpoint_url=model_config.endpoint_url,
+            rate_per_min=model_config.rate_per_min,
+            model_name=self.endpoint_configuration.model_name,
+            model_version=self.endpoint_configuration.model_version,
+            model_auth_type=model_config.model_auth_type,
+            model_jwt_config=model_config.model_jwt_config,
+            model_api_key=model_config.apikey,
+            input_modalities=[
+                InputModality(m) if isinstance(m, str) else m
+                for m in model_config.input_modalities
+            ],
+            output_modalities=[
+                OutputModality(m) if isinstance(m, str) else m
+                for m in model_config.output_modalities
+            ],
+            custom_curl_command=model_config.custom_curl_command,
+            custom_headers=model_config.custom_headers,
+            custom_payload=model_config.custom_payload,
+            custom_response_content_type=model_config.custom_response_content_type,
+            custom_response_format=model_config.custom_response_format,
+        )
+
+
 @dataclass
 class RedteamModelHealthResponse(BaseDTO):
     status: str
@@ -522,22 +605,22 @@ class RedteamModelHealthResponse(BaseDTO):
     error: str
     data: Optional[Dict[str, Any]] = field(default_factory=dict)
     _extra_fields: Dict[str, Any] = field(default_factory=dict)
-    
+
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "RedteamModelHealthResponse":
         return cls(
             status=data.get("status", ""),
             message=data.get("message", ""),
             data=data.get("data", {}),
-            error=data.get("error", "")
+            error=data.get("error", ""),
         )
-    
+
     def to_dict(self) -> Dict[str, Any]:
         return {
             "status": self.status,
             "message": self.message,
             "data": self.data,
-            "error": self.error
+            "error": self.error,
         }
 
 
@@ -610,24 +693,27 @@ class RedTeamConfigWithSavedModel(BaseDTO):
 @dataclass
 class RedTeamCustomConfig(BaseDTO):
     test_name: str = "Test Name"
+    frameworks: List[str] = field(default_factory=list)
 
     redteam_test_configurations: RedTeamTestConfigurations = field(
         default_factory=RedTeamTestConfigurations
     )
-    dataset_configuration: DatasetConfig = field(
-        default_factory=DatasetConfig
-    )
-    endpoint_configuration: ModelConfig = field(
-        default_factory=ModelConfig
-    )
+    dataset_configuration: Optional[DatasetConfig] = None
+    endpoint_configuration: Optional[ModelConfig] = None
 
     _extra_fields: Dict[str, Any] = field(default_factory=dict)
 
     def to_dict(self) -> dict:
         d = asdict(self)
         d["redteam_test_configurations"] = self.redteam_test_configurations.to_dict()
-        d["dataset_configuration"] = self.dataset_configuration.to_dict()
-        d["endpoint_configuration"] = self.endpoint_configuration.to_dict()
+        if self.dataset_configuration is not None:
+            d["dataset_configuration"] = self.dataset_configuration.to_dict()
+        else:
+            d.pop("dataset_configuration", None)
+        if self.endpoint_configuration is not None:
+            d["endpoint_configuration"] = self.endpoint_configuration.to_dict()
+        else:
+            d.pop("endpoint_configuration", None)
         return d
 
     @classmethod
@@ -636,12 +722,18 @@ class RedTeamCustomConfig(BaseDTO):
         test_configs = RedTeamTestConfigurations.from_dict(
             data.pop("redteam_test_configurations", {})
         )
-        dataset_config = DatasetConfig.from_dict(
-            data.pop("dataset_configuration", {})
-        )
-        endpoint_config = ModelConfig.from_dict(
-            data.pop("endpoint_configuration", {})
-        )
+        dataset_config = None
+        if "dataset_configuration" in data and data["dataset_configuration"]:
+            dataset_config = DatasetConfig.from_dict(data.pop("dataset_configuration"))
+        else:
+            data.pop("dataset_configuration", None)
+
+        endpoint_config = None
+        if "endpoint_configuration" in data and data["endpoint_configuration"]:
+            endpoint_config = ModelConfig.from_dict(data.pop("endpoint_configuration"))
+        else:
+            data.pop("endpoint_configuration", None)
+
         return cls(
             **data,
             redteam_test_configurations=test_configs,
@@ -649,23 +741,26 @@ class RedTeamCustomConfig(BaseDTO):
             endpoint_configuration=endpoint_config,
         )
 
+
 @dataclass
 class RedTeamCustomConfigWithSavedModel(BaseDTO):
     test_name: str = "Test Name"
+    frameworks: List[str] = field(default_factory=list)
 
     redteam_test_configurations: RedTeamTestConfigurations = field(
         default_factory=RedTeamTestConfigurations
     )
-    dataset_configuration: DatasetConfig = field(
-        default_factory=DatasetConfig
-    )
+    dataset_configuration: Optional[DatasetConfig] = None
 
     _extra_fields: Dict[str, Any] = field(default_factory=dict)
 
     def to_dict(self) -> dict:
         d = asdict(self)
         d["redteam_test_configurations"] = self.redteam_test_configurations.to_dict()
-        d["dataset_configuration"] = self.dataset_configuration.to_dict()
+        if self.dataset_configuration is not None:
+            d["dataset_configuration"] = self.dataset_configuration.to_dict()
+        else:
+            d.pop("dataset_configuration", None)
         return d
 
     @classmethod
@@ -674,9 +769,12 @@ class RedTeamCustomConfigWithSavedModel(BaseDTO):
         test_configs = RedTeamTestConfigurations.from_dict(
             data.pop("redteam_test_configurations", {})
         )
-        dataset_config = DatasetConfig.from_dict(
-            data.pop("dataset_configuration", {})
-        )
+        dataset_config = None
+        if "dataset_configuration" in data and data["dataset_configuration"]:
+            dataset_config = DatasetConfig.from_dict(data.pop("dataset_configuration"))
+        else:
+            data.pop("dataset_configuration", None)
+
         return cls(
             **data,
             redteam_test_configurations=test_configs,
@@ -691,7 +789,7 @@ class RedTeamTaskList(BaseDTO):
     def to_dataframe(self) -> pd.DataFrame:
         data = [task for task in self.tasks]
         return pd.DataFrame(data)
-    
+
 
 @dataclass
 class RedTeamRiskMitigationGuardrailsPolicyConfig(BaseDTO):
@@ -735,21 +833,21 @@ class RedTeamRiskMitigationGuardrailsPolicyResponse(BaseDTO):
 
     def to_dict(self) -> dict:
         policy_dict = self.guardrails_policy.to_dict()
-        
+
         # Remove detector entries that are disabled and have no other config
         final_policy_dict = {}
         for key, value in policy_dict.items():
             if isinstance(value, dict):
                 # Check if 'enabled' is the only key and its value is False
-                if list(value.keys()) == ['enabled'] and not value['enabled']:
+                if list(value.keys()) == ["enabled"] and not value["enabled"]:
                     continue
                 # Check for empty detectors that only have 'enabled': False
                 if not value.get("enabled", True) and len(value) == 1:
                     continue
                 # check for other empty values
-                if not any(v for k, v in value.items() if k != 'enabled'):
-                     if not value.get('enabled'):
-                         continue
+                if not any(v for k, v in value.items() if k != "enabled"):
+                    if not value.get("enabled"):
+                        continue
                 final_policy_dict[key] = value
 
         return {
@@ -804,21 +902,18 @@ class RedTeamRiskMitigationSystemPromptResponse(BaseDTO):
             "message": self.message,
         }
 
+
 @dataclass
 class RedTeamKeyFinding(BaseDTO):
     text: str
     _extra_fields: Dict[str, Any] = field(default_factory=dict)
-    
+
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "RedTeamKeyFinding":
-        return cls(
-            text=data.get("text", "")
-        )
-    
+        return cls(text=data.get("text", ""))
+
     def to_dict(self) -> Dict[str, Any]:
-        result = {
-            "text": self.text
-        }
+        result = {"text": self.text}
         result.update(self._extra_fields)
         return result
 
@@ -828,26 +923,240 @@ class RedTeamFindingsResponse(BaseDTO):
     key_findings: List[RedTeamKeyFinding] = field(default_factory=list)
     message: str = ""
     _extra_fields: Dict[str, Any] = field(default_factory=dict)
-    
+
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "RedTeamFindingsResponse":
         key_findings_data = data.get("key_findings", [])
-        key_findings = [RedTeamKeyFinding.from_dict(finding) for finding in key_findings_data]
-        
+        key_findings = [
+            RedTeamKeyFinding.from_dict(finding) for finding in key_findings_data
+        ]
+
+        return cls(key_findings=key_findings, message=data.get("message", ""))
+
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "key_findings": [finding.to_dict() for finding in self.key_findings],
+            "message": self.message,
+        }
+        result.update(self._extra_fields)
+        return result
+
+
+@dataclass
+class RedTeamDownloadLinkResponse(BaseDTO):
+    link: str = ""
+    expiry: str = ""
+    expires_at: str = ""
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "RedTeamDownloadLinkResponse":
         return cls(
-            key_findings=key_findings,
-            message=data.get("message", "")
+            link=data.get("link", ""),
+            expiry=data.get("expiry", ""),
+            expires_at=data.get("expires_at", ""),
         )
-    
+
     def to_dict(self) -> Dict[str, Any]:
         result = {
-            "key_findings": [finding.to_dict() for finding in self.key_findings],
-            "message": self.message
+            "link": self.link,
+            "expiry": self.expiry,
+            "expires_at": self.expires_at,
         }
         result.update(self._extra_fields)
         return result
 
 
+# V3 Attack Methods and Test Configurations
+@dataclass
+class AttackMethodsV3(BaseDTO):
+    """
+    V3 format for attack methods with nested structure:
+    {
+        "method_category": {
+            "method_name": {
+                "params": {}
+            }
+        }
+    }
+    """
+
+    _data: Dict[str, Dict[str, Dict[str, Any]]] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return self._data
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(_data=data)
+
+
+@dataclass
+class TestConfigV3(BaseDTO):
+    sample_percentage: int = 5
+    attack_methods: AttackMethodsV3 = field(default_factory=AttackMethodsV3)
+
+    def to_dict(self) -> dict:
+        return {
+            "sample_percentage": self.sample_percentage,
+            "attack_methods": self.attack_methods.to_dict(),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        attack_methods = AttackMethodsV3.from_dict(data.get("attack_methods", {}))
+        return cls(
+            sample_percentage=data.get("sample_percentage", 5),
+            attack_methods=attack_methods,
+        )
+
+
+@dataclass
+class RedTeamTestConfigurationsV3(BaseDTO):
+    """V3 format for red team test configurations with nested attack methods"""
+
+    version: str = "3.0"
+    # Basic tests
+    bias_test: TestConfigV3 = field(default=None)
+    cbrn_test: TestConfigV3 = field(default=None)
+    csem_test: TestConfigV3 = field(default=None)
+    insecure_code_test: TestConfigV3 = field(default=None)
+    toxicity_test: TestConfigV3 = field(default=None)
+    harmful_test: TestConfigV3 = field(default=None)
+    pii_test: TestConfigV3 = field(default=None)
+    copyright_test: TestConfigV3 = field(default=None)
+    misinformation_test: TestConfigV3 = field(default=None)
+    system_prompt_extractions_test: TestConfigV3 = field(default=None)
+    sponge_test: TestConfigV3 = field(default=None)
+    # Advanced tests
+    adv_info_test: TestConfigV3 = field(default=None)
+    adv_bias_test: TestConfigV3 = field(default=None)
+    adv_tool_test: TestConfigV3 = field(default=None)
+    adv_command_test: TestConfigV3 = field(default=None)
+    adv_pii_test: TestConfigV3 = field(default=None)
+    adv_competitor_test: TestConfigV3 = field(default=None)
+    # Custom tests
+    custom_test: TestConfigV3 = field(default=None)
+    # Agents tests
+    alignment_and_governance_test: TestConfigV3 = field(default=None)
+    input_and_content_integrity_test: TestConfigV3 = field(default=None)
+    infrastructure_and_integration_test: TestConfigV3 = field(default=None)
+    security_and_privacy_test: TestConfigV3 = field(default=None)
+    human_factors_and_societal_impact_test: TestConfigV3 = field(default=None)
+    access_control_test: TestConfigV3 = field(default=None)
+    physical_and_actuation_safety_test: TestConfigV3 = field(default=None)
+    reliability_and_monitoring_test: TestConfigV3 = field(default=None)
+    governance_test: TestConfigV3 = field(default=None)
+    agent_output_quality_test: TestConfigV3 = field(default=None)
+    tool_misuse_test: TestConfigV3 = field(default=None)
+    privacy_test: TestConfigV3 = field(default=None)
+    reliability_and_observability_test: TestConfigV3 = field(default=None)
+    agent_behaviour_test: TestConfigV3 = field(default=None)
+    access_control_and_permissions_test: TestConfigV3 = field(default=None)
+    tool_extraction_test: TestConfigV3 = field(default=None)
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(
+            **{
+                k: TestConfigV3.from_dict(v) if isinstance(v, dict) else v
+                for k, v in data.items()
+            }
+        )
+
+
+@dataclass
+class RedTeamCustomConfigV3(BaseDTO):
+    test_name: str = "Test Name"
+    frameworks: List[str] = field(default_factory=list)
+
+    redteam_test_configurations: RedTeamTestConfigurationsV3 = field(
+        default_factory=RedTeamTestConfigurationsV3
+    )
+    dataset_configuration: Optional[DatasetConfig] = None
+    endpoint_configuration: Optional[ModelConfig] = None
+
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        d = asdict(self)
+        d["redteam_test_configurations"] = self.redteam_test_configurations.to_dict()
+        if self.dataset_configuration is not None:
+            d["dataset_configuration"] = self.dataset_configuration.to_dict()
+        else:
+            d.pop("dataset_configuration", None)
+        if self.endpoint_configuration is not None:
+            d["endpoint_configuration"] = self.endpoint_configuration.to_dict()
+        else:
+            d.pop("endpoint_configuration", None)
+        return d
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        data = data.copy()
+        test_configs = RedTeamTestConfigurationsV3.from_dict(
+            data.pop("redteam_test_configurations", {})
+        )
+        dataset_config = None
+        if "dataset_configuration" in data and data["dataset_configuration"]:
+            dataset_config = DatasetConfig.from_dict(data.pop("dataset_configuration"))
+        else:
+            data.pop("dataset_configuration", None)
+
+        endpoint_config = None
+        if "endpoint_configuration" in data and data["endpoint_configuration"]:
+            endpoint_config = ModelConfig.from_dict(data.pop("endpoint_configuration"))
+        else:
+            data.pop("endpoint_configuration", None)
+
+        return cls(
+            **data,
+            redteam_test_configurations=test_configs,
+            dataset_configuration=dataset_config,
+            endpoint_configuration=endpoint_config,
+        )
+
+
+@dataclass
+class RedTeamCustomConfigWithSavedModelV3(BaseDTO):
+    test_name: str = "Test Name"
+    frameworks: List[str] = field(default_factory=list)
+
+    redteam_test_configurations: RedTeamTestConfigurationsV3 = field(
+        default_factory=RedTeamTestConfigurationsV3
+    )
+    dataset_configuration: Optional[DatasetConfig] = None
+
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        d = asdict(self)
+        d["redteam_test_configurations"] = self.redteam_test_configurations.to_dict()
+        if self.dataset_configuration is not None:
+            d["dataset_configuration"] = self.dataset_configuration.to_dict()
+        else:
+            d.pop("dataset_configuration", None)
+        return d
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        data = data.copy()
+        test_configs = RedTeamTestConfigurationsV3.from_dict(
+            data.pop("redteam_test_configurations", {})
+        )
+        dataset_config = None
+        if "dataset_configuration" in data and data["dataset_configuration"]:
+            dataset_config = DatasetConfig.from_dict(data.pop("dataset_configuration"))
+        else:
+            data.pop("dataset_configuration", None)
+
+        return cls(
+            **data,
+            redteam_test_configurations=test_configs,
+            dataset_configuration=dataset_config,
+        )
+
 
 # Default configurations
 DEFAULT_REDTEAM_CONFIG = RedTeamConfig()
@@ -855,3 +1164,8 @@ DEFAULT_REDTEAM_CONFIG_WITH_SAVED_MODEL = RedTeamConfigWithSavedModel()
 
 DEFAULT_CUSTOM_REDTEAM_CONFIG = RedTeamCustomConfig()
 DEFAULT_CUSTOM_REDTEAM_CONFIG_WITH_SAVED_MODEL = RedTeamCustomConfigWithSavedModel()
+
+DEFAULT_CUSTOM_REDTEAM_CONFIG_V3 = RedTeamCustomConfigV3()
+DEFAULT_CUSTOM_REDTEAM_CONFIG_WITH_SAVED_MODEL_V3 = (
+    RedTeamCustomConfigWithSavedModelV3()
+)