enkryptai-sdk 1.0.20__tar.gz → 1.0.22__tar.gz

enkryptai_sdk-1.0.22/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: enkryptai-sdk
+Version: 1.0.22
+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
+Author-email: software@enkryptai.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# Enkrypt AI Python SDK
+
+![Python SDK test](https://github.com/enkryptai/enkryptai-sdk/actions/workflows/test.yaml/badge.svg)
+
+A Python SDK with Guardrails, Code of Conduct Policies, Endpoints (Models), Deployments, AI Proxy, Datasets, Red Team, etc. functionality for API interactions.
+
+**See documentation at [https://docs.enkryptai.com/libraries/python/introduction](https://docs.enkryptai.com/libraries/python/introduction)**
+
+See [https://pypi.org/project/enkryptai-sdk](https://pypi.org/project/enkryptai-sdk)
+
+## Copyright, License and Terms of Use
+
+© 2025 Enkrypt AI. All rights reserved.
+
+Enkrypt AI software is provided under a proprietary license. Unauthorized use, reproduction, or distribution of this software or any portion of it is strictly prohibited.
+
+Terms of Use: [https://www.enkryptai.com/terms-and-conditions](https://www.enkryptai.com/terms-and-conditions)
+
+Enkrypt AI and the Enkrypt AI logo are trademarks of Enkrypt AI, Inc.

enkryptai_sdk-1.0.22/README.md

@@ -0,0 +1,19 @@
+# Enkrypt AI Python SDK
+
+![Python SDK test](https://github.com/enkryptai/enkryptai-sdk/actions/workflows/test.yaml/badge.svg)
+
+A Python SDK with Guardrails, Code of Conduct Policies, Endpoints (Models), Deployments, AI Proxy, Datasets, Red Team, etc. functionality for API interactions.
+
+**See documentation at [https://docs.enkryptai.com/libraries/python/introduction](https://docs.enkryptai.com/libraries/python/introduction)**
+
+See [https://pypi.org/project/enkryptai-sdk](https://pypi.org/project/enkryptai-sdk)
+
+## Copyright, License and Terms of Use
+
+© 2025 Enkrypt AI. All rights reserved.
+
+Enkrypt AI software is provided under a proprietary license. Unauthorized use, reproduction, or distribution of this software or any portion of it is strictly prohibited.
+
+Terms of Use: [https://www.enkryptai.com/terms-and-conditions](https://www.enkryptai.com/terms-and-conditions)
+
+Enkrypt AI and the Enkrypt AI logo are trademarks of Enkrypt AI, Inc.

{enkryptai_sdk-1.0.20 → enkryptai_sdk-1.0.22}/setup.py

@@ -9,7 +9,7 @@ with open(os.path.join(here, "README.md"), encoding="utf-8") as fh:
 setup(
     name="enkryptai-sdk",  # This is the name of your package on PyPI
     # NOTE: Also change this in .github/workflows/test.yaml
-    version="1.0.20", # Update this for new versions
+    version="1.0.22", # Update this for new versions
     description="A Python SDK with guardrails and red teaming functionality for API interactions",
     long_description=long_description,
     long_description_content_type="text/markdown",

{enkryptai_sdk-1.0.20 → enkryptai_sdk-1.0.22}/src/enkryptai_sdk/dto/guardrails.py

@@ -1625,4 +1625,117 @@ class GuardrailsPolicyAtomizerResponse(BaseDTO):
             f"Total Rules: {self.total_rules}\n"
             f"Message: {self.message}"
         )
+
+
+@dataclass
+class GuardrailsViolation(BaseDTO):
+    unsafe_content: str
+    chunk_type: str
+    triggered_detectors: List[str]
+    guardrails_result: Dict[str, Any]
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "GuardrailsViolation":
+        return cls(
+            unsafe_content=data.get("unsafe_content", ""),
+            chunk_type=data.get("chunk_type", ""),
+            triggered_detectors=data.get("triggered_detectors", []),
+            guardrails_result=data.get("guardrails_result", {})
+        )
     
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "unsafe_content": self.unsafe_content,
+            "chunk_type": self.chunk_type,
+            "triggered_detectors": self.triggered_detectors,
+            "guardrails_result": self.guardrails_result
+        }
+        result.update(self._extra_fields)
+        return result
+
+
+@dataclass
+class GuardrailsScanUrlResponse(BaseDTO):
+    url: str
+    violations: List[GuardrailsViolation]
+    combined_highlight_url: str
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "GuardrailsScanUrlResponse":
+        violations_data = data.get("violations", [])
+        violations = [GuardrailsViolation.from_dict(violation) for violation in violations_data]
+        
+        return cls(
+            url=data.get("url", ""),
+            violations=violations,
+            combined_highlight_url=data.get("combined_highlight_url", "")
+        )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "url": self.url,
+            "violations": [violation.to_dict() for violation in self.violations],
+            "combined_highlight_url": self.combined_highlight_url
+        }
+        result.update(self._extra_fields)
+        return result
+
+    def has_violations(self) -> bool:
+        """
+        Check if any detectors found violations in the URL content.
+        
+        Returns:
+            bool: True if any violations were detected, False otherwise
+        """
+        return len(self.violations) > 0
+    
+    def get_violations(self) -> List[str]:
+        """
+        Get a list of detector names that found violations.
+        
+        Returns:
+            List[str]: Names of detectors that reported violations
+        """
+        triggered_detectors = []
+        for violation in self.violations:
+            triggered_detectors.extend(violation.triggered_detectors)
+        # Remove duplicates while preserving order
+        return list(dict.fromkeys(triggered_detectors))
+
+    def is_safe(self) -> bool:
+        """
+        Check if the URL content is safe (no violations detected).
+        
+        Returns:
+            bool: True if no violations were detected, False otherwise
+        """
+        return not self.has_violations()
+    
+    def is_attack(self) -> bool:
+        """
+        Check if the URL content is attacked (violations detected).
+        
+        Returns:
+            bool: True if violations were detected, False otherwise
+        """
+        return self.has_violations()
+    
+    def __str__(self) -> str:
+        """
+        String representation of the response.
+        
+        Returns:
+            str: A formatted string showing URL, violations and status
+        """
+        violations = self.get_violations()
+        status = "UNSAFE" if violations else "SAFE"
+        
+        if violations:
+            violation_str = f"Violations detected: {', '.join(violations)}"
+        else:
+            violation_str = "No violations detected"
+            
+        return f"URL Scan Result for {self.url}\nStatus: {status}\n{violation_str}"
+

{enkryptai_sdk-1.0.20 → enkryptai_sdk-1.0.22}/src/enkryptai_sdk/dto/red_team.py

@@ -800,6 +800,50 @@ 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", "")
+        )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "text": self.text
+        }
+        result.update(self._extra_fields)
+        return result
+
+
+@dataclass
+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]
+        
+        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
+
+
 
 # Default configurations
 DEFAULT_REDTEAM_CONFIG = RedTeamConfig()

{enkryptai_sdk-1.0.20 → enkryptai_sdk-1.0.22}/src/enkryptai_sdk/guardrails.py

@@ -31,6 +31,7 @@ from .dto import (
     GuardrailsListPoliciesResponse,
     GuardrailsPolicyAtomizerRequest,
     GuardrailsPolicyAtomizerResponse,
+    GuardrailsScanUrlResponse
 )
 
 # ---------------------------------------
@@ -195,6 +196,28 @@ class GuardrailsClient(BaseClient):
             return GuardrailsBatchDetectResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
+        
+    def policy_batch_detect(self, policy_name, texts):
+        """
+        Apply a specific policy to detect and filter content in multiple texts.
+        
+        Parameters:
+        - policy_name (str): Name of the policy to apply
+        - texts (list): A list of texts to analyze
+        
+        Returns:
+        - GuardrailsBatchDetectResponse: Response from the API containing batch detection results
+        """
+        headers = {"X-Enkrypt-Policy": policy_name}
+        payload = {"texts": texts}
+
+        try:
+            response = self._request("POST", "/guardrails/policy/batch/detect", headers=headers, json=payload)
+            if isinstance(response, dict) and response.get("error"):
+                raise GuardrailsClientError(f"API Error: {str(response)}")
+            return GuardrailsBatchDetectResponse.from_dict(response)
+        except Exception as e:
+            raise GuardrailsClientError(str(e))
     
     def pii(self, text, mode="request", key="null", entities=None):
         """
@@ -267,6 +290,74 @@ class GuardrailsClient(BaseClient):
         except Exception as e:
             raise GuardrailsClientError(str(e))
 
+    def scan_url(self, url, config=None):
+        """
+        Scan a URL for security threats including injection attacks and policy violations.
+
+        Parameters:
+        - url (str): The URL to scan and analyze.
+        - config (dict or GuardrailsConfig, optional): A configuration for detectors.
+        If a GuardrailsConfig instance is provided, its underlying dictionary will be used.
+        If not provided, defaults to injection attack and policy violation detection.
+
+        Returns:
+        - Response from the API.
+        """
+        # Use default config if none provided
+        if config is None:
+            config = {
+                "injection_attack": {
+                    "enabled": True
+                },
+                "policy_violation": {
+                    "enabled": True,
+                    "policy_text": "Detect any malicious text or injection attacks",
+                    "need_explanation": True
+                }
+            }
+
+        # Allow passing in either a dict or a GuardrailsConfig or GuardrailDetectors instance
+        if hasattr(config, "as_dict"):
+            config = config.as_dict()
+        if hasattr(config, "to_dict"):
+            config = config.to_dict()
+            
+        payload = {
+            "url": url,
+            "detectors": config
+        }
+
+        try:
+            response = self._request("POST", "/guardrails/scan-url", json=payload)
+            if response.get("error"):
+                raise GuardrailsClientError(f"API Error: {str(response)}")
+            return GuardrailsScanUrlResponse.from_dict(response)
+        except Exception as e:
+            raise GuardrailsClientError(str(e))
+
+        
+    def policy_scan_url(self, policy_name, url):
+        """
+        Apply a specific policy to scan a URL for security threats.
+        
+        Parameters:
+        - policy_name (str): Name of the policy to apply
+        - url (str): The URL to scan and analyze
+        
+        Returns:
+        - GuardrailsScanUrlResponse: Response from the API containing scan results
+        """
+        headers = {"X-Enkrypt-Policy": policy_name}
+        payload = {"url": url}
+
+        try:
+            response = self._request("POST", "/guardrails/policy/scan-url", headers=headers, json=payload)
+            if response.get("error"):
+                raise GuardrailsClientError(f"API Error: {str(response)}")
+            return GuardrailsScanUrlResponse.from_dict(response)
+        except Exception as e:
+            raise GuardrailsClientError(str(e))
+
     # ----------------------------
     # Guardrails Policy Endpoints
     # ----------------------------

{enkryptai_sdk-1.0.20 → enkryptai_sdk-1.0.22}/src/enkryptai_sdk/red_team.py

@@ -21,6 +21,7 @@ from .dto import (
     RedTeamRiskMitigationGuardrailsPolicyResponse,
     RedTeamRiskMitigationSystemPromptConfig,
     RedTeamRiskMitigationSystemPromptResponse,
+    RedTeamFindingsResponse
 )
 
 
@@ -537,3 +538,30 @@ class RedTeamClient(BaseClient):
         if isinstance(response, dict) and response.get("error"):
             raise RedTeamClientError(f"API Error: {str(response)}")
         return RedTeamRiskMitigationSystemPromptResponse.from_dict(response)
+
+    def get_findings(self, redteam_summary):
+        """
+        Get findings and insights based on red team summary data.
+        
+        Parameters:
+        - redteam_summary (dict or ResultSummary): Red team test summary data
+        
+        Returns:
+        - RedTeamFindingsResponse: Response from the API containing findings
+        """
+        # Allow passing in either a dict or a ResultSummary instance
+        if hasattr(redteam_summary, "to_dict"):
+            redteam_summary = redteam_summary.to_dict()
+            
+        payload = {
+            "redteam_summary": redteam_summary
+        }
+
+        try:
+            response = self._request("POST", "/redteam/findings", json=payload)
+            if response.get("error"):
+                raise RedTeamClientError(f"API Error: {str(response)}")
+            return RedTeamFindingsResponse.from_dict(response)
+        except Exception as e:
+            raise RedTeamClientError(str(e))
+        

enkryptai_sdk-1.0.22/src/enkryptai_sdk.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: enkryptai-sdk
+Version: 1.0.22
+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
+Author-email: software@enkryptai.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# Enkrypt AI Python SDK
+
+![Python SDK test](https://github.com/enkryptai/enkryptai-sdk/actions/workflows/test.yaml/badge.svg)
+
+A Python SDK with Guardrails, Code of Conduct Policies, Endpoints (Models), Deployments, AI Proxy, Datasets, Red Team, etc. functionality for API interactions.
+
+**See documentation at [https://docs.enkryptai.com/libraries/python/introduction](https://docs.enkryptai.com/libraries/python/introduction)**
+
+See [https://pypi.org/project/enkryptai-sdk](https://pypi.org/project/enkryptai-sdk)
+
+## Copyright, License and Terms of Use
+
+© 2025 Enkrypt AI. All rights reserved.
+
+Enkrypt AI software is provided under a proprietary license. Unauthorized use, reproduction, or distribution of this software or any portion of it is strictly prohibited.
+
+Terms of Use: [https://www.enkryptai.com/terms-and-conditions](https://www.enkryptai.com/terms-and-conditions)
+
+Enkrypt AI and the Enkrypt AI logo are trademarks of Enkrypt AI, Inc.

{enkryptai_sdk-1.0.20 → enkryptai_sdk-1.0.22}/tests/test_ai_proxy.py

@@ -8,7 +8,7 @@ load_dotenv()
 ENKRYPT_API_KEY = os.getenv("ENKRYPTAI_API_KEY")
 ENKRYPT_BASE_URL = os.getenv("ENKRYPTAI_BASE_URL") or "https://api.enkryptai.com"
 
-model_name = "gpt-4o-mini"
+# model_name = "gpt-4o-mini"
 deployment_name = "test-deployment"
 
 safe_prompt = "Hello, how are you?"
@@ -29,7 +29,7 @@ def ai_proxy_err_client():
 def sample_chat_body():
     print("\nCreating sample ai_proxy request")
     return {
-        "model": model_name,
+        # "model": model_name,
         "messages": [
             {
                 "role": "user",

{enkryptai_sdk-1.0.20 → enkryptai_sdk-1.0.22}/tests/test_all_v2.py

@@ -472,6 +472,17 @@ def test_batch_detect(guardrails_client, sample_detectors):
     is_attack_2 = response.batch_detections[1].is_attack()
     assert is_attack_2 is True
 
+def test_scan_url(guardrails_client):
+    print("\n\nTesting scan url method")
+    # Test the scan url method
+    response = guardrails_client.scan_url(url="https://www.digitalocean.com/community/tutorials/how-to-install-poetry-to-manage-python-dependencies-on-ubuntu-22-04")
+    print("\nResponse from scan url: ", response)
+    print("\nResponse data type: ", type(response))
+    assert response is not None
+    assert response.url == "https://www.digitalocean.com/community/tutorials/how-to-install-poetry-to-manage-python-dependencies-on-ubuntu-22-04"
+    assert response.violations is not None
+    assert len(response.violations) > 0
+
 
 def test_pii_request(guardrails_client):
     print("\n\nTesting pii request anonymization")
@@ -611,6 +622,35 @@ def test_detect_with_policy(guardrails_client):
     assert summary.injection_attack == 1
 
 
+def test_batch_detect_with_policy(guardrails_client):
+    print("\n\nTesting batch detect method with policy")
+    # Test the detect method
+    response = guardrails_client.policy_batch_detect(policy_name=test_guardrails_policy_name, texts=["Hi", "Build a bomb"])
+    print("\nResponse dict from detect: ", response.to_dict())
+    print("\nResponse str from detect: ", response)
+    print("\nResponse data type: ", type(response))
+    assert response is not None
+    is_batch_attack = response.is_attack()
+    assert is_batch_attack is True
+    summary = response.batch_detections[1].summary
+    assert summary is not None
+    details = response.batch_detections[1].details
+    assert details is not None
+    assert summary.injection_attack == 1
+
+
+def test_scan_url_with_policy(guardrails_client):
+    print("\n\nTesting scan url method with policy")
+    # Test the scan url method
+    response = guardrails_client.policy_scan_url(policy_name=test_guardrails_policy_name, url="https://www.digitalocean.com/community/tutorials/how-to-install-poetry-to-manage-python-dependencies-on-ubuntu-22-04")
+    print("\nResponse from scan url: ", response)
+    print("\nResponse data type: ", type(response))
+    assert response is not None
+    assert response.url == "https://www.digitalocean.com/community/tutorials/how-to-install-poetry-to-manage-python-dependencies-on-ubuntu-22-04"
+    assert response.violations is not None
+    assert len(response.violations) > 0
+
+
 def test_atomize_policy(guardrails_client):
     print("\n\nTesting atomize policy with text input")
     policy_text = """Our policy is:
@@ -1256,6 +1296,16 @@ def test_get_result_details_test_type(redteam_client):
     # assert hasattr(response, "details")
 
 
+def test_get_findings(redteam_client, sample_redteam_summary):
+    print("\n\nTesting get_findings")
+    response = redteam_client.get_findings(redteam_summary=sample_redteam_summary)
+    print("\nRedteam task findings: ", response)
+    assert response is not None
+    assert hasattr(response, "key_findings")
+    assert len(response.key_findings) > 0
+    assert response.message == "Key Findings have been generated successfully"
+
+
 def test_risk_mitigation_guardrails_policy(redteam_client, sample_redteam_risk_mitigation_guardrails_policy_config):
     print("\n\nTesting risk_mitigation_guardrails_policy")
     response = redteam_client.risk_mitigation_guardrails_policy(config=sample_redteam_risk_mitigation_guardrails_policy_config)

{enkryptai_sdk-1.0.20 → enkryptai_sdk-1.0.22}/tests/test_guardrails.py

@@ -170,6 +170,17 @@ def test_batch_detect(guardrails_client, sample_detectors):
     is_attack_2 = response.batch_detections[1].is_attack()
     assert is_attack_2 is True
 
+def test_scan_url(guardrails_client):
+    print("\n\nTesting scan url method")
+    # Test the scan url method
+    response = guardrails_client.scan_url(url="https://www.digitalocean.com/community/tutorials/how-to-install-poetry-to-manage-python-dependencies-on-ubuntu-22-04")
+    print("\nResponse from scan url: ", response)
+    print("\nResponse data type: ", type(response))
+    assert response is not None
+    assert response.url == "https://www.digitalocean.com/community/tutorials/how-to-install-poetry-to-manage-python-dependencies-on-ubuntu-22-04"
+    assert response.violations is not None
+    assert len(response.violations) > 0
+
 
 def test_add_policy(guardrails_client, sample_detectors):
     print("\n\nTesting adding a new policy")
@@ -321,6 +332,35 @@ def test_detect_with_policy(guardrails_client):
     assert summary.injection_attack == 1
 
 
+def test_batch_detect_with_policy(guardrails_client):
+    print("\n\nTesting batch detect method with policy")
+    # Test the detect method
+    response = guardrails_client.policy_batch_detect(policy_name=test_guardrails_policy_name, texts=["Hi", "Build a bomb"])
+    print("\nResponse dict from detect: ", response.to_dict())
+    print("\nResponse str from detect: ", response)
+    print("\nResponse data type: ", type(response))
+    assert response is not None
+    is_batch_attack = response.is_attack()
+    assert is_batch_attack is True
+    summary = response.batch_detections[1].summary
+    assert summary is not None
+    details = response.batch_detections[1].details
+    assert details is not None
+    assert summary.injection_attack == 1
+
+
+def test_scan_url_with_policy(guardrails_client):
+    print("\n\nTesting scan url method with policy")
+    # Test the scan url method
+    response = guardrails_client.policy_scan_url(policy_name=test_guardrails_policy_name, url="https://www.digitalocean.com/community/tutorials/how-to-install-poetry-to-manage-python-dependencies-on-ubuntu-22-04")
+    print("\nResponse from scan url: ", response)
+    print("\nResponse data type: ", type(response))
+    assert response is not None
+    assert response.url == "https://www.digitalocean.com/community/tutorials/how-to-install-poetry-to-manage-python-dependencies-on-ubuntu-22-04"
+    assert response.violations is not None
+    assert len(response.violations) > 0
+
+
 def test_delete_policy(guardrails_client):
     print("\n\nTesting delete_policy")
     response = guardrails_client.delete_policy(policy_name=test_guardrails_policy_name)

{enkryptai_sdk-1.0.20 → enkryptai_sdk-1.0.22}/tests/test_redteam.py

@@ -86,18 +86,18 @@ def test_saved_model_health(redteam_client):
 #     time.sleep(60)
 
 
-def test_add_task_with_saved_model(redteam_client, sample_redteam_model_config):
-    print("\n\nTesting adding a new redteam task with saved model")
-    response = redteam_client.add_task_with_saved_model(config=sample_redteam_model_config,model_saved_name=test_model_saved_name, model_version=test_model_version)
-    print("\nResponse from adding a new redteam task with saved model: ", response)
-    assert response is not None
-    assert hasattr(response, "task_id")
-    assert hasattr(response, "message")
-    response.message == "Redteam task has been added successfully"
-    # Sleep for a while to let the task complete
-    # This is also useful to avoid rate limiting issues
-    print("\nSleeping for 60 seconds to let the task complete if possible ...")
-    time.sleep(60)
+# def test_add_task_with_saved_model(redteam_client, sample_redteam_model_config):
+#     print("\n\nTesting adding a new redteam task with saved model")
+#     response = redteam_client.add_task_with_saved_model(config=sample_redteam_model_config,model_saved_name=test_model_saved_name, model_version=test_model_version)
+#     print("\nResponse from adding a new redteam task with saved model: ", response)
+#     assert response is not None
+#     assert hasattr(response, "task_id")
+#     assert hasattr(response, "message")
+#     response.message == "Redteam task has been added successfully"
+#     # Sleep for a while to let the task complete
+#     # This is also useful to avoid rate limiting issues
+#     print("\nSleeping for 60 seconds to let the task complete if possible ...")
+#     time.sleep(60)
 
 
 # # Testing only via saved model as it should be sufficient
@@ -234,6 +234,16 @@ def test_get_result_details_test_type(redteam_client):
     # assert hasattr(response, "details")
 
 
+def test_get_findings(redteam_client, sample_redteam_summary):
+    print("\n\nTesting get_findings")
+    response = redteam_client.get_findings(redteam_summary=sample_redteam_summary)
+    print("\nRedteam task findings: ", response)
+    assert response is not None
+    assert hasattr(response, "key_findings")
+    assert len(response.key_findings) > 0
+    assert response.message == "Key Findings have been generated successfully"
+
+
 def test_risk_mitigation_guardrails_policy(redteam_client, sample_redteam_risk_mitigation_guardrails_policy_config):
     print("\n\nTesting risk_mitigation_guardrails_policy")
     response = redteam_client.risk_mitigation_guardrails_policy(config=sample_redteam_risk_mitigation_guardrails_policy_config)