enkryptai-sdk 1.0.14__py3-none-any.whl → 1.0.16__py3-none-any.whl

enkryptai_sdk/dto/guardrails.py

@@ -243,6 +243,19 @@ class SystemPromptDetector(BaseDTO):
         }
 
 
+class GuardrailDetectorsEnum(str, Enum):
+    TOPIC_DETECTOR = "topic_detector"
+    NSFW = "nsfw"
+    TOXICITY = "toxicity"
+    PII = "pii"
+    INJECTION_ATTACK = "injection_attack"
+    KEYWORD_DETECTOR = "keyword_detector"
+    POLICY_VIOLATION = "policy_violation"
+    BIAS = "bias"
+    COPYRIGHT_IP = "copyright_ip"
+    SYSTEM_PROMPT = "system_prompt"
+
+
 @dataclass
 class GuardrailDetectors(BaseDTO):
     topic_detector: TopicDetector = field(default_factory=TopicDetector)

enkryptai_sdk/dto/models.py

@@ -40,6 +40,7 @@ class ModelProviders(str, Enum):
     CUSTOM = "custom"
     HR = "hr"
     URL = "url"
+    ENKRYPTAI = "enkryptai"
 
 
 @dataclass
@@ -92,10 +93,11 @@ class ModelDetailConfig:
     # model_provider: str = "openai"
     model_provider: ModelProviders = ModelProviders.OPENAI
     system_prompt: str = ""
-
-    endpoint_url: str = "https://api.openai.com/v1/chat/completions"
+    endpoint_url: str = ""
     auth_data: AuthData = field(default_factory=AuthData)
+    metadata: Dict[str, Any] = field(default_factory=dict)
     api_keys: Set[Optional[str]] = field(default_factory=lambda: {None})
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
 
 
 @dataclass
@@ -159,7 +161,7 @@ class ModelConfigDetails(BaseDTO):
     headers: str = ""
     system_prompt: str = ""
     hosting_type: str = "External"
-    endpoint_url: str = "https://api.openai.com/v1/chat/completions"
+    endpoint_url: str = ""
     model_name: Optional[str] = ""
     apikey: Optional[str] = None
     paths: Optional[PathsConfig] = None

enkryptai_sdk/dto/red_team.py

@@ -5,6 +5,19 @@ from typing import Dict, List, Optional, Any
 from dataclasses import dataclass, field, asdict
 from .datasets import DatasetConfig
 from .models import ModelConfig
+from .guardrails import GuardrailDetectors
+
+# The risk mitigation do not support all detectors, so we need to create a separate enum for them.
+class RiskGuardrailDetectorsEnum(str, Enum):
+    NSFW = "nsfw"
+    TOXICITY = "toxicity"
+    INJECTION_ATTACK = "injection_attack"
+    POLICY_VIOLATION = "policy_violation"
+    BIAS = "bias"
+    # Topic, Keyword, PII are not supported by Risk Mitigation
+    # Below are not yet supported by Guardrails. So, also not supported by Risk Mitigation.
+    # COPYRIGHT_IP = "copyright_ip"
+    # SYSTEM_PROMPT = "system_prompt"
 
 
 @dataclass
@@ -49,13 +62,59 @@ class RedTeamTaskStatus(BaseDTO):
     status: Optional[str] = None
 
 
+@dataclass
+class RedTeamTaskDetailsModelConfig(BaseDTO):
+    system_prompt: Optional[str] = None
+    model_version: Optional[str] = None
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "RedTeamTaskDetailsModelConfig":
+        return cls(
+            system_prompt=data.get("system_prompt"),
+            model_version=data.get("model_version"),
+        )
+    
+    def to_dict(self) -> Dict:
+        return {
+            "system_prompt": self.system_prompt,
+            "model_version": self.model_version,
+        }
+
+
 @dataclass
 class RedTeamTaskDetails(BaseDTO):
     created_at: Optional[str] = None
+    model_saved_name: Optional[str] = None
     model_name: Optional[str] = None
     status: Optional[str] = None
     test_name: Optional[str] = None
     task_id: Optional[str] = None
+    model_config: Optional[RedTeamTaskDetailsModelConfig] = None
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "RedTeamTaskDetails":
+        return cls(
+            created_at=data.get("created_at"),
+            model_saved_name=data.get("model_saved_name"),
+            model_name=data.get("model_name"),
+            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", {})),
+        )
+    
+    def to_dict(self) -> Dict:
+        return {
+            "created_at": self.created_at,
+            "model_saved_name": self.model_saved_name,
+            "model_name": self.model_name,
+            "status": self.status,
+            "test_name": self.test_name,
+            "task_id": self.task_id,
+            "model_config": self.model_config.to_dict(),
+        }
 
 
 @dataclass
@@ -114,6 +173,7 @@ class ResultSummary(BaseDTO):
     scenario: Dict[str, StatisticItem]
     category: Dict[str, StatisticItemWithTestType]
     attack_method: Dict[str, StatisticItem]
+    custom_test_category_risks: Dict[str, StatisticItem] = field(default_factory=dict)
     _extra_fields: Dict[str, Any] = field(default_factory=dict)
 
     @classmethod
@@ -146,6 +206,9 @@ class ResultSummary(BaseDTO):
             scenario=convert_stat_list(data.get("scenario", [])),
             category=convert_stat_test_type_list(data.get("category", [])),
             attack_method=convert_stat_list(data.get("attack_method", [])),
+            custom_test_category_risks=convert_stat_list(
+                data.get("custom_test_category_risks", [])
+            ),
         )
 
     def to_dict(self) -> Dict:
@@ -162,6 +225,9 @@ class ResultSummary(BaseDTO):
         d["scenario"] = convert_stat_dict(self.scenario)
         d["category"] = convert_stat_test_type_dict(self.category)
         d["attack_method"] = convert_stat_dict(self.attack_method)
+        d["custom_test_category_risks"] = convert_stat_dict(
+            self.custom_test_category_risks
+        )
         return d
 
 
@@ -578,6 +644,118 @@ class RedTeamTaskList(BaseDTO):
     def to_dataframe(self) -> pd.DataFrame:
         data = [task for task in self.tasks]
         return pd.DataFrame(data)
+    
+
+@dataclass
+class RedTeamRiskMitigationGuardrailsPolicyConfig(BaseDTO):
+    # required_detectors: List[RiskGuardrailDetectorsEnum] = field(default_factory=list)
+    redteam_summary: ResultSummary = field(default_factory=ResultSummary)
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        data = data.copy()
+        summary = ResultSummary.from_dict(data.pop("redteam_summary", {}))
+        return cls(
+            # required_detectors=[RiskGuardrailDetectorsEnum(detector) for detector in data.get("required_detectors", [])],
+            redteam_summary=summary,
+            _extra_fields=data,
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            # "required_detectors": [detector.value for detector in self.required_detectors],
+            "redteam_summary": self.redteam_summary.to_dict(),
+        }
+
+
+@dataclass
+class RedTeamRiskMitigationGuardrailsPolicyResponse(BaseDTO):
+    analysis: str = ""
+    guardrails_policy: GuardrailDetectors = field(default_factory=GuardrailDetectors)
+    message: str = ""
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        policy_data = data.get("guardrails_policy", {})
+
+        return cls(
+            analysis=data.get("analysis", ""),
+            guardrails_policy=GuardrailDetectors.from_dict(policy_data),
+            message=data.get("message", ""),
+        )
+
+    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']:
+                    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
+                final_policy_dict[key] = value
+
+        return {
+            "analysis": self.analysis,
+            "guardrails_policy": final_policy_dict,
+            "message": self.message,
+        }
+
+
+@dataclass
+class RedTeamRiskMitigationSystemPromptConfig(BaseDTO):
+    system_prompt: str = "You are a helpful AI Assistant"
+    redteam_summary: ResultSummary = field(default_factory=ResultSummary)
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        data = data.copy()
+        summary = ResultSummary.from_dict(data.pop("redteam_summary", {}))
+        return cls(
+            system_prompt=data.get("system_prompt", ""),
+            redteam_summary=summary,
+            _extra_fields=data,
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "system_prompt": self.system_prompt,
+            "redteam_summary": self.redteam_summary.to_dict(),
+        }
+
+
+@dataclass
+class RedTeamRiskMitigationSystemPromptResponse(BaseDTO):
+    analysis: str = ""
+    system_prompt: str = ""
+    message: str = ""
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(
+            analysis=data.get("analysis", ""),
+            system_prompt=data.get("system_prompt", ""),
+            message=data.get("message", ""),
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "analysis": self.analysis,
+            "system_prompt": self.system_prompt,
+            "message": self.message,
+        }
 
 
 # Default configurations

enkryptai_sdk/models.py

@@ -29,17 +29,29 @@ class ModelClient(BaseClient):
         if isinstance(config, dict):
             config = ModelConfig.from_dict(config)
         
-        # Parse endpoint_url into components
-        parsed_url = urlparse(config.model_config.endpoint_url)
-        path_parts = parsed_url.path.strip("/").split("/")
-
-        # Extract base_path and endpoint path
-        if len(path_parts) >= 1:
-            base_path = path_parts[0]  # Usually 'v1'
-            remaining_path = "/".join(path_parts[1:])  # The rest of the path
-        else:
-            base_path = ""
-            remaining_path = ""
+        endpoint_data = {}
+        base_path = ""
+        remaining_path = ""
+
+        if config.model_config.endpoint_url:
+            # Parse endpoint_url into components
+            parsed_url = urlparse(config.model_config.endpoint_url)
+            path_parts = parsed_url.path.strip("/").split("/")
+
+            # Extract base_path and endpoint path
+            if len(path_parts) >= 1:
+                base_path = path_parts[0]  # Usually 'v1'
+                remaining_path = "/".join(path_parts[1:])  # The rest of the path
+            else:
+                base_path = ""
+                remaining_path = ""
+            
+            endpoint_data = {
+                    "scheme": parsed_url.scheme,
+                    "host": parsed_url.hostname,
+                    "port": parsed_url.port or (443 if parsed_url.scheme == "https" else 80),
+                    "base_path": f"/{base_path}",
+                }
 
         if config.model_config.paths:
             paths = config.model_config.paths.to_dict()
@@ -61,12 +73,7 @@ class ModelClient(BaseClient):
                 "hosting_type": config.model_config.hosting_type,
                 "model_source": config.model_config.model_source,
                 "system_prompt": config.model_config.system_prompt,
-                "endpoint": {
-                    "scheme": parsed_url.scheme,
-                    "host": parsed_url.hostname,
-                    "port": parsed_url.port or (443 if parsed_url.scheme == "https" else 80),
-                    "base_path": f"/{base_path}",
-                },
+                "endpoint": endpoint_data,
                 "paths": paths,
                 "auth_data": {
                     "header_name": config.model_config.auth_data.header_name,
@@ -149,92 +156,33 @@ class ModelClient(BaseClient):
         except Exception as e:
             return {"error": str(e)}
 
-    def modify_model(self, config: ModelConfig, old_model_saved_name=None, old_model_version=None) -> ModelResponse:
+    def modify_model(self, config: ModelConfig | dict, old_model_saved_name=None, old_model_version=None) -> ModelResponse:
         """
         Modify an existing model in the system.
 
         Args:
-            old_model_saved_name (str): The old saved name of the model to modify
-            old_model_version (str): The old version of the model to modify
-            config (ModelConfig): Configuration object containing model details
+            config (Union[ModelConfig, dict]): Configuration object or dictionary containing model details
+            old_model_saved_name (str, optional): The old saved name of the model to modify. Defaults to None.
+            old_model_version (str, optional): The old version of the model to modify. Defaults to None.
 
         Returns:
             dict: Response from the API containing the modified model details
         """
+        
+        temp_config = config
+        if isinstance(temp_config, dict):
+            temp_config = ModelConfig.from_dict(temp_config)
+
         if old_model_saved_name is None:
-            old_model_saved_name = config["model_saved_name"]
+            old_model_saved_name = temp_config.model_saved_name
 
         if old_model_version is None:
-            old_model_version = config["model_version"]
+            old_model_version = temp_config.model_version
 
         headers = {"Content-Type": "application/json", "X-Enkrypt-Model": old_model_saved_name, "X-Enkrypt-Model-Version": old_model_version}
-        # print(config)
-        config = ModelConfig.from_dict(config)
-        # Parse endpoint_url into components
-        parsed_url = urlparse(config.model_config.endpoint_url)
-        path_parts = parsed_url.path.strip("/").split("/")
-
-        # Extract base_path and endpoint path
-        if len(path_parts) >= 1:
-            base_path = path_parts[0]  # Usually 'v1'
-            remaining_path = "/".join(path_parts[1:])  # The rest of the path
-        else:
-            base_path = ""
-            remaining_path = ""
-
-        if config.model_config.paths:
-            paths = config.model_config.paths.to_dict()
-        else:
-            # Determine paths based on the endpoint
-            paths = {
-                "completions": (
-                    f"/{remaining_path.split('/')[-1]}" if remaining_path else ""
-                ),
-                "chat": f"/{remaining_path}" if remaining_path else "",
-            }
-
-        # Convert custom_headers to list of dictionaries
-        custom_headers = [header.to_dict() for header in config.model_config.custom_headers]
+        
+        payload = self.prepare_model_payload(temp_config)
 
-        payload = {
-            "model_saved_name": config.model_saved_name,
-            "model_version": config.model_version,
-            "testing_for": config.testing_for,
-            "model_name": config.model_name,
-            "certifications": config.certifications,
-            "model_config": {
-                "model_provider": config.model_config.model_provider,
-                "hosting_type": config.model_config.hosting_type,
-                "model_source": config.model_config.model_source,
-                "system_prompt": config.model_config.system_prompt,
-                "endpoint": {
-                    "scheme": parsed_url.scheme,
-                    "host": parsed_url.hostname,
-                    "port": parsed_url.port
-                    or (443 if parsed_url.scheme == "https" else 80),
-                    "base_path": f"/{base_path}",  # Just v1
-                },
-                "paths": paths,
-                "auth_data": {
-                    "header_name": config.model_config.auth_data.header_name,
-                    "header_prefix": config.model_config.auth_data.header_prefix,
-                    "space_after_prefix": config.model_config.auth_data.space_after_prefix,
-                },
-                "apikeys": (
-                    [config.model_config.apikey] if config.model_config.apikey else []
-                ),
-                "tools": config.model_config.tools,
-                "input_modalities": [m.value if hasattr(m, 'value') else m for m in config.model_config.input_modalities],
-                "output_modalities": [m.value if hasattr(m, 'value') else m for m in config.model_config.output_modalities],
-                "custom_curl_command": config.model_config.custom_curl_command,
-                "custom_headers": custom_headers,
-                "custom_payload": config.model_config.custom_payload,
-                "custom_response_content_type": config.model_config.custom_response_content_type,
-                "custom_response_format": config.model_config.custom_response_format,
-                "metadata": config.model_config.metadata,
-                "default_request_options": config.model_config.default_request_options,
-            },
-        }
         try:
             response = self._request(
                 "PATCH", "/models/modify-model", headers=headers, json=payload

enkryptai_sdk/red_team.py

@@ -17,6 +17,10 @@ from .dto import (
     RedTeamTaskStatus,
     RedTeamTaskDetails,
     RedTeamTaskList,
+    RedTeamRiskMitigationGuardrailsPolicyConfig,
+    RedTeamRiskMitigationGuardrailsPolicyResponse,
+    RedTeamRiskMitigationSystemPromptConfig,
+    RedTeamRiskMitigationSystemPromptResponse,
 )
 
 
@@ -508,3 +512,27 @@ class RedTeamClient(BaseClient):
         if isinstance(response, dict) and response.get("error"):
             raise RedTeamClientError(f"API Error: {str(response)}")
         return RedTeamTaskList.from_dict(response)
+
+    def risk_mitigation_guardrails_policy(self, config: RedTeamRiskMitigationGuardrailsPolicyConfig):
+        """
+        Get the guardrails policy generated for risk mitigation.
+        """
+        config = RedTeamRiskMitigationGuardrailsPolicyConfig.from_dict(config)
+        payload = config.to_dict()
+        
+        response = self._request("POST", "/redteam/risk-mitigation/guardrails-policy", json=payload)
+        if isinstance(response, dict) and response.get("error"):
+            raise RedTeamClientError(f"API Error: {str(response)}")
+        return RedTeamRiskMitigationGuardrailsPolicyResponse.from_dict(response)
+
+    def risk_mitigation_system_prompt(self, config: RedTeamRiskMitigationSystemPromptConfig):
+        """
+        Get the system prompt generated for risk mitigation.
+        """
+        config = RedTeamRiskMitigationSystemPromptConfig.from_dict(config)
+        payload = config.to_dict()
+        
+        response = self._request("POST", "/redteam/risk-mitigation/system-prompt", json=payload)
+        if isinstance(response, dict) and response.get("error"):
+            raise RedTeamClientError(f"API Error: {str(response)}")
+        return RedTeamRiskMitigationSystemPromptResponse.from_dict(response)

{enkryptai_sdk-1.0.14.dist-info → enkryptai_sdk-1.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: enkryptai-sdk
-Version: 1.0.14
+Version: 1.0.16
 Summary: A Python SDK with guardrails and red teaming functionality for API interactions
 Home-page: https://github.com/enkryptai/enkryptai-sdk
 Author: Enkrypt AI Team
@@ -49,6 +49,8 @@ Also see the API documentation at [https://docs.enkryptai.com](https://docs.enkr
   - [Sample Redteam Model Config](#sample-redteam-model-config)
   - [Sample Custom Redteam Target Config](#sample-custom-redteam-target-config)
   - [Sample Custom Redteam Model Config](#sample-custom-redteam-model-config)
+  - [Sample Redteam Risk Mitigation Guardrails Policy Config](#sample-redteam-risk-mitigation-guardrails-policy-config)
+  - [Sample Redteam Risk Mitigation System Prompt Config](#sample-redteam-risk-mitigation-system-prompt-config)
 - [Health Checks](#health-checks)
   - [Guardrails Health](#guardrails-health)
   - [Guardrails Status](#guardrails-status)
@@ -124,6 +126,8 @@ Also see the API documentation at [https://docs.enkryptai.com](https://docs.enkr
   - [Get Redteam Task Results Summary of Test Type](#get-redteam-task-results-summary-of-test-type)
   - [Get Redteam Task Results Details](#get-redteam-task-results-details)
   - [Get Redteam Task Results Details of Test Type](#get-redteam-task-results-details-of-test-type)
+  - [Mitigate Risks with Guardrails Policy](#mitigate-risks-with-guardrails-policy)
+  - [Mitigate Risks with System Prompt](#mitigate-risks-with-system-prompt)
 - [Copyright, License, and Terms of Use](#copyright-license-and-terms-of-use)
 
 ## Installation
@@ -518,6 +522,289 @@ sample_custom_redteam_model_config = {
     }
 ```
 
+### [Sample Redteam Risk Mitigation Guardrails Policy Config](https://docs.enkryptai.com/redteam-api-reference/endpoint/risk-mitigation-guardrails-policy)
+
+```python Python
+sample_redteam_risk_mitigation_guardrails_policy_config = {
+        "redteam_summary": {
+            "category": [
+                {
+                    "Biology": {
+                        "total": 50,
+                        "test_type": "cbrn_test",
+                        "success(%)": 92
+                    }
+                },
+                {
+                    "Chemistry": {
+                        "total": 50,
+                        "test_type": "cbrn_test",
+                        "success(%)": 98
+                    }
+                },
+                {
+                    "Fraud": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 73
+                    }
+                },
+                {
+                    "Guns & Illegal Substances": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 87
+                    }
+                },
+                {
+                    "Hate Speech and Discrimination": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 53
+                    }
+                },
+                {
+                    "Nuclear Science": {
+                        "total": 50,
+                        "test_type": "cbrn_test",
+                        "success(%)": 94
+                    }
+                },
+                {
+                    "Radiology": {
+                        "total": 50,
+                        "test_type": "cbrn_test",
+                        "success(%)": 84
+                    }
+                },
+                {
+                    "Regulated or Controlled Substances": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 74
+                    }
+                },
+                {
+                    "Sexual Content": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 79
+                    }
+                },
+                {
+                    "Suicide & Self-Harm": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 72
+                    }
+                },
+                {
+                    "Unethical Crimes": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 83
+                    }
+                },
+                {
+                    "Violent Crimes": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 70
+                    }
+                }
+            ],
+            "scenario": [],
+            "test_date": "2020-01-01T17:14:33.607823+00:00",
+            "test_name": "Mistral Small Latest x Red Team",
+            "test_type": [
+                {
+                    "cbrn_test": {
+                        "total": 200,
+                        "success(%)": 92
+                    }
+                },
+                {
+                    "harmful_test": {
+                        "total": 800,
+                        "success(%)": 73.88
+                    }
+                }
+            ],
+            "model_name": "mistral-small-latest",
+            "risk_score": 82.9375,
+            "dataset_name": "Standard",
+            "model_source": "",
+            "attack_method": [
+                {
+                    "Basic": {
+                        "total": 1000,
+                        "success(%)": 77.5
+                    }
+                }
+            ],
+            "nist_category": [
+                {
+                    "CBRN Information or Capabilities": {
+                        "total": 200,
+                        "success(%)": 92
+                    }
+                },
+                {
+                    "Dangerous, Violent, or Hateful Content": {
+                        "total": 800,
+                        "success(%)": 73.88
+                    }
+                }
+            ],
+            "model_provider": "mistral",
+            "model_endpoint_url": "https://api.mistral.ai/v1/chat/completions",
+            "custom_test_category_risks": []
+        }
+    }
+```
+
+### [Sample Redteam Risk Mitigation System Prompt Config](https://docs.enkryptai.com/redteam-api-reference/endpoint/risk-mitigation-system-prompt)
+
+```python Python
+sample_redteam_risk_mitigation_system_prompt_config = {
+        "system_prompt": "You are a helpful AI Assistant",
+        "redteam_summary": {
+            "category": [
+                {
+                    "Biology": {
+                        "total": 50,
+                        "test_type": "cbrn_test",
+                        "success(%)": 92
+                    }
+                },
+                {
+                    "Chemistry": {
+                        "total": 50,
+                        "test_type": "cbrn_test",
+                        "success(%)": 98
+                    }
+                },
+                {
+                    "Fraud": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 73
+                    }
+                },
+                {
+                    "Guns & Illegal Substances": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 87
+                    }
+                },
+                {
+                    "Hate Speech and Discrimination": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 53
+                    }
+                },
+                {
+                    "Nuclear Science": {
+                        "total": 50,
+                        "test_type": "cbrn_test",
+                        "success(%)": 94
+                    }
+                },
+                {
+                    "Radiology": {
+                        "total": 50,
+                        "test_type": "cbrn_test",
+                        "success(%)": 84
+                    }
+                },
+                {
+                    "Regulated or Controlled Substances": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 74
+                    }
+                },
+                {
+                    "Sexual Content": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 79
+                    }
+                },
+                {
+                    "Suicide & Self-Harm": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 72
+                    }
+                },
+                {
+                    "Unethical Crimes": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 83
+                    }
+                },
+                {
+                    "Violent Crimes": {
+                        "total": 100,
+                        "test_type": "harmful_test",
+                        "success(%)": 70
+                    }
+                }
+            ],
+            "scenario": [],
+            "test_date": "2020-01-01T17:14:33.607823+00:00",
+            "test_name": "Mistral Small Latest x Red Team",
+            "test_type": [
+                {
+                    "cbrn_test": {
+                        "total": 200,
+                        "success(%)": 92
+                    }
+                },
+                {
+                    "harmful_test": {
+                        "total": 800,
+                        "success(%)": 73.88
+                    }
+                }
+            ],
+            "model_name": "mistral-small-latest",
+            "risk_score": 82.9375,
+            "dataset_name": "Standard",
+            "model_source": "",
+            "attack_method": [
+                {
+                    "Basic": {
+                        "total": 1000,
+                        "success(%)": 77.5
+                    }
+                }
+            ],
+            "nist_category": [
+                {
+                    "CBRN Information or Capabilities": {
+                        "total": 200,
+                        "success(%)": 92
+                    }
+                },
+                {
+                    "Dangerous, Violent, or Hateful Content": {
+                        "total": 800,
+                        "success(%)": 73.88
+                    }
+                }
+            ],
+            "model_provider": "mistral",
+            "model_endpoint_url": "https://api.mistral.ai/v1/chat/completions",
+            "custom_test_category_risks": []
+        }
+    }
+```
+
 ## Health Checks
 
 ### [Guardrails Health](https://docs.enkryptai.com/guardrails-api-reference/endpoint/health-check)
@@ -694,8 +981,8 @@ print(batch_detect_response.to_dict())
 - `nsfw`: Filter inappropriate content
 - `toxicity`: Detect toxic language
 - `pii`: Detect personal information
-- `copyright_ip`: Check for copyright/IP violations *(Coming soon)*
-- `system_prompt`: Detect system prompt leaks *(Coming soon)*
+- `copyright_ip`: Check for copyright/IP violations ***(Coming soon)***
+- `system_prompt`: Detect system prompt leaks ***(Coming soon)***
 - `keyword_detector`: Check for specific keywords
 
 Each detector can be enabled/disabled and configured with specific options as documented in the [API docs](https://docs.enkryptai.com/guardrails-api-reference/introduction).
@@ -757,7 +1044,7 @@ guardrails_config = GuardrailsConfig.keyword(keywords=["secret", "password"])
 
 ### [Copyright IP](https://docs.enkryptai.com/guardrails-api-reference/Copyright_IP_Leak_Detector)
 
-*(Coming soon)*
+- ***(Coming soon)***
 
 ```python Python
 guardrails_config = GuardrailsConfig.copyright_ip()
@@ -765,7 +1052,7 @@ guardrails_config = GuardrailsConfig.copyright_ip()
 
 ### [System Prompt](https://docs.enkryptai.com/guardrails-api-reference/System_Prompt_Leak_Detector)
 
-*(Coming soon)*
+- ***(Coming soon)***
 
 ```python Python
 guardrails_config = GuardrailsConfig.system_prompt(index="system")
@@ -969,7 +1256,7 @@ print(relevancy_response.to_dict())
 
 ### [Check Hallucination](https://docs.enkryptai.com/guardrails-api-reference/Hallucination)
 
-*(Coming soon)*
+- ***(Coming soon)***
 
 Detect hallucinations in an LLM's response:
 
@@ -1660,6 +1947,32 @@ print(redteam_results_details_test_type.task_status)
 print(redteam_results_details_test_type.to_dict())
 ```
 
+### [Mitigate Risks with Guardrails Policy](https://docs.enkryptai.com/redteam-api-reference/endpoint/risk-mitigation-guardrails-policy)
+
+```python Python
+# Mitigate risks with guardrails policy
+risk_mitigation_guardrails_policy_response = redteam_client.risk_mitigation_guardrails_policy(config=copy.deepcopy(sample_redteam_risk_mitigation_guardrails_policy_config))
+
+print(risk_mitigation_guardrails_policy_response)
+print(risk_mitigation_guardrails_policy_response.guardrails_policy)
+
+# Print as a dictionary
+print(risk_mitigation_guardrails_policy_response.to_dict())
+```
+
+### [Mitigate Risks with System Prompt](https://docs.enkryptai.com/redteam-api-reference/endpoint/risk-mitigation-system-prompt)
+
+```python Python
+# Mitigate risks with system prompt
+risk_mitigation_system_prompt_response = redteam_client.risk_mitigation_system_prompt(config=copy.deepcopy(sample_redteam_risk_mitigation_system_prompt_config))
+
+print(risk_mitigation_system_prompt_response)
+print(risk_mitigation_system_prompt_response.system_prompt)
+
+# Print as a dictionary
+print(risk_mitigation_system_prompt_response.to_dict())
+```
+
 ## Copyright, License and Terms of Use
 
 © 2025 Enkrypt AI. All rights reserved.

{enkryptai_sdk-1.0.14.dist-info → enkryptai_sdk-1.0.16.dist-info}/RECORD

@@ -8,8 +8,8 @@ enkryptai_sdk/deployments.py,sha256=A7XZ2JwrMod9V4_aV8bFY_Soh9E3jHdwaTuJ9BwXuyk,
 enkryptai_sdk/evals.py,sha256=BywyEgIT7xdJ58svO_sDNOMVowdB0RTGoAZPEbCnDVo,2595
 enkryptai_sdk/guardrails.py,sha256=NluimOA0gM9N3S_q47LTUeG97t9PlYqPHlZahDPkJvI,16365
 enkryptai_sdk/guardrails_old.py,sha256=SgzPZkTzbAPD9XfmYNG6M1-TrzbhDHpAkI3FjnVWS_s,6434
-enkryptai_sdk/models.py,sha256=rrLTT3i96flWidVrr67j6VZ6XmkdxwEzlF4S4aoVmOQ,11559
-enkryptai_sdk/red_team.py,sha256=A1b6R5d3dtZMfb5npBrSu4RX2X-C9V4hubyO9g3BZlA,18441
+enkryptai_sdk/models.py,sha256=OfADGvP2gy52_fXT5iAj81Q07iDGAEYWiKYLD_ycozU,8786
+enkryptai_sdk/red_team.py,sha256=cjN4LODbpYiECcoL0JROMcCPCzm3Ib6kXi7kQspP4hQ,19869
 enkryptai_sdk/response.py,sha256=43JRubzgGCpoVxYNzBZY0AlUgLbfcXD_AwD7wU3qY9o,4086
 enkryptai_sdk/dto/__init__.py,sha256=wHgIv_OCnVMJOys-vqImF59ifogDrMcgxVRmfNayVvc,2761
 enkryptai_sdk/dto/ai_proxy.py,sha256=clwMN4xdH8Zr55dnhilHbs-qaHRlCOrLPrij0Zd1Av0,11283
@@ -17,11 +17,11 @@ enkryptai_sdk/dto/base.py,sha256=y77kQL1X7389ifSVNc0E7CUFNxACh5AM3ml9YPon1KY,282
 enkryptai_sdk/dto/coc.py,sha256=Lp2aat_24J4KuUg4BeJl9S39tEak8Bw15eJ4cQDrRQk,4749
 enkryptai_sdk/dto/datasets.py,sha256=RFA9CmbhD-QDDyweBq_k9iBd00b6I6SWmdP9DPNd9fc,5002
 enkryptai_sdk/dto/deployments.py,sha256=Aw4b8tDA3FYIomqDvCjblCXTagL4bT8Fx91X0SFXs40,11216
-enkryptai_sdk/dto/guardrails.py,sha256=wfKm2R0uJAq9nljLBPuuT05tj1nBqZraga-5lMHd3n8,49812
-enkryptai_sdk/dto/models.py,sha256=zldbvYV5zcg1J3UZh4UnaeM1cBx-_LCCyW-LtfBcjaQ,14246
-enkryptai_sdk/dto/red_team.py,sha256=GD_HxFhoaEixyaZLVdoLHmHDXFRf9b-Wq6RT-UJNQfM,18344
-enkryptai_sdk-1.0.14.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-enkryptai_sdk-1.0.14.dist-info/METADATA,sha256=m6amEeDX9HURaZab4Wn_LMISj8WmxUQ8pTRRtd3Ogwo,62009
-enkryptai_sdk-1.0.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-enkryptai_sdk-1.0.14.dist-info/top_level.txt,sha256=s2X9UJJwvJamNmr6ZXWyyQe60sXtQGWFuaBYfhgHI_4,14
-enkryptai_sdk-1.0.14.dist-info/RECORD,,
+enkryptai_sdk/dto/guardrails.py,sha256=oJQqFhsdQd_yPU187AhKse-Y4xktgmVNwwKKkzFazbg,50167
+enkryptai_sdk/dto/models.py,sha256=SDzNMwxDVIp2D1qO29ere8WgqC5n_bJuitesaoxitZo,14312
+enkryptai_sdk/dto/red_team.py,sha256=EHwDbDM0mMLDyGB_kN4KEOO65ng9Bn51q9O3IdwO5Ng,24766
+enkryptai_sdk-1.0.16.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+enkryptai_sdk-1.0.16.dist-info/METADATA,sha256=T7ws5lOF-ynN_Z3cegMX0Ysotjp2_n7pet8Ci-ULFmI,72860
+enkryptai_sdk-1.0.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+enkryptai_sdk-1.0.16.dist-info/top_level.txt,sha256=s2X9UJJwvJamNmr6ZXWyyQe60sXtQGWFuaBYfhgHI_4,14
+enkryptai_sdk-1.0.16.dist-info/RECORD,,