enkryptai-sdk 1.0.7__py3-none-any.whl → 1.0.9__py3-none-any.whl

enkryptai_sdk/dto/datasets.py

@@ -21,17 +21,20 @@ class Tool(BaseDTO):
             "description": self.description
         }
 
+
 @dataclass
 class DatasetConfig(BaseDTO):
-    dataset_name: str
-    system_description: str
-    policy_description: str = ""
-    tools: List[Tool] = field(default_factory=list)
-    info_pdf_url: str = ""
+    system_description: str = None
+    dataset_name: str = None
+    policy_description: str = None
+    risk_categories: str = None
+    tools: List[Tool] = None
+    info_pdf_url: str = None
     max_prompts: int = 100
     scenarios: int = 2
     categories: int = 2
     depth: int = 2
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
 
 
 @dataclass
@@ -51,6 +54,7 @@ class DatasetDataPoint(BaseDTO):
     category: str
     prompt: str
     source: str
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
 
 
 @dataclass

enkryptai_sdk/dto/guardrails.py

@@ -1,8 +1,7 @@
 from enum import Enum
 from .base import BaseDTO
 from dataclasses import dataclass, field
-from typing import List, Dict, Any, Set
-
+from typing import List, Dict, Any, Set, Optional, BinaryIO
 
 class GuardrailsPIIModes(str, Enum):
     REQUEST = "request"
@@ -1334,13 +1333,13 @@ class GuardrailsPolicyData(BaseDTO):
 
 
 @dataclass
-class GuardrailsaPolicyResponse(BaseDTO):
+class GuardrailsPolicyResponse(BaseDTO):
     message: str
     data: GuardrailsPolicyData
     _extra_fields: Dict[str, Any] = field(default_factory=dict)
     
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "GuardrailsaPolicyResponse":
+    def from_dict(cls, data: Dict[str, Any]) -> "GuardrailsPolicyResponse":
         policy_data = data.get("data", {})
         return cls(
             message=data.get("message", ""),
@@ -1454,3 +1453,109 @@ class GuardrailsListPoliciesResponse(BaseDTO):
         result.update(self._extra_fields)
         return result
 
+
+# -------------------------------------
+# Guardrails Policy Atomizer
+# -------------------------------------
+
+@dataclass
+class GuardrailsPolicyAtomizerRequest(BaseDTO):
+    text: Optional[str] = None
+    file: Optional[BinaryIO] = None
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "GuardrailsPolicyAtomizerRequest":
+        return cls(
+            file=data.get("file", None),
+            text=data.get("text", None)
+        )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        result = {}
+        if self.file:
+            result["file"] = self.file
+        if self.text:
+            result["text"] = self.text
+        result.update(self._extra_fields)
+        return result
+
+    def validate(self) -> bool:
+        """
+        Validate that either file or text is provided, but not both.
+        
+        Returns:
+            bool: True if valid, False otherwise
+        """
+        return bool(self.file) != bool(self.text)  # XOR - only one should be True
+
+
+@dataclass
+class GuardrailsPolicyAtomizerResponse(BaseDTO):
+    status: str = ""
+    message: str = ""
+    source: str = ""
+    filename: str = ""
+    total_rules: int = 0
+    policy_rules: str = ""
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "GuardrailsPolicyAtomizerResponse":
+        return cls(
+            status=data.get("status", "success"),
+            message=data.get("message", ""),
+            source=data.get("source", ""),
+            filename=data.get("filename", ""),
+            total_rules=data.get("total_rules", 0),
+            policy_rules=data.get("policy_rules", "")
+        )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "status": self.status,
+            "message": self.message,
+            "source": self.source,
+            "filename": self.filename,
+            "total_rules": self.total_rules,
+            "policy_rules": self.policy_rules
+        }
+        result.update(self._extra_fields)
+        return result
+
+    def is_successful(self) -> bool:
+        """
+        Check if the atomization was successful.
+        
+        Returns:
+            bool: True if status is "success", False otherwise
+        """
+        return self.status == "success"
+
+    def get_rules_list(self) -> List[str]:
+        """
+        Get the policy rules as a list of strings.
+        
+        Returns:
+            List[str]: List of individual policy rules
+        """
+        if not self.policy_rules:
+            return []
+        return [rule.strip() for rule in self.policy_rules.split('\n') if rule.strip()]
+
+    def __str__(self) -> str:
+        """
+        String representation of the response.
+        
+        Returns:
+            str: A formatted string showing the atomization results
+        """
+        source_info = f"File: {self.filename}" if self.source == "upload" else "Source: Text input"
+        return (
+            f"Policy Atomizer Response:\n"
+            f"Status: {self.status}\n"
+            f"{source_info}\n"
+            f"Total Rules: {self.total_rules}\n"
+            f"Message: {self.message}"
+        )
+    

enkryptai_sdk/dto/models.py

@@ -142,8 +142,8 @@ class CustomHeader(BaseDTO):
 
 @dataclass
 class ModelConfigDetails(BaseDTO):
-    model_id: str = ""
-    model_source: str = ""
+    model_id: str = None
+    model_source: str = None
     # model_provider: str = "openai"
     model_provider: ModelProviders = ModelProviders.OPENAI
     model_api_value: str = ""
@@ -259,14 +259,14 @@ class ModelConfigDetails(BaseDTO):
 
 @dataclass
 class ModelConfig(BaseDTO):
-    created_at: str = ""
-    updated_at: str = ""
-    model_id: str = ""
-    model_saved_name: str = "Model Name"
-    model_version: str = "v1"
+    created_at: str = None
+    updated_at: str = None
+    model_id: str = None
+    model_saved_name: str = None
+    model_version: str = None
     testing_for: str = "foundationModels"
     # modality: Modality = Modality.TEXT
-    project_name: str = ""
+    project_name: str = None
     model_name: Optional[str] = "gpt-4o-mini"
     certifications: List[str] = field(default_factory=list)
     model_config: ModelConfigDetails = field(default_factory=ModelConfigDetails)

enkryptai_sdk/dto/red_team.py

@@ -3,6 +3,8 @@ from enum import Enum
 from .base import BaseDTO
 from typing import Dict, List, Optional, Any
 from dataclasses import dataclass, field, asdict
+from .datasets import DatasetConfig
+from .models import ModelConfig
 
 
 @dataclass
@@ -24,6 +26,7 @@ class RedteamHealthResponse(BaseDTO):
 
 @dataclass
 class RedTeamResponse(BaseDTO):
+    status: Optional[str] = None
     task_id: Optional[str] = None
     message: Optional[str] = None
     data: Optional[Dict[str, Any]] = None
@@ -300,7 +303,7 @@ class RedTeamTestConfigurations(BaseDTO):
     adv_info_test: TestConfig = field(default=None)
     adv_bias_test: TestConfig = field(default=None)
     adv_command_test: TestConfig = field(default=None)
-    # custom_test: TestConfig = field(default=None)
+    custom_test: TestConfig = field(default=None)
     _extra_fields: Dict[str, Any] = field(default_factory=dict)
 
     @classmethod
@@ -482,6 +485,83 @@ class RedTeamConfigWithSavedModel(BaseDTO):
         )
 
 
+@dataclass
+class RedTeamCustomConfig(BaseDTO):
+    test_name: str = "Test Name"
+
+    redteam_test_configurations: RedTeamTestConfigurations = field(
+        default_factory=RedTeamTestConfigurations
+    )
+    dataset_configuration: DatasetConfig = field(
+        default_factory=DatasetConfig
+    )
+    endpoint_configuration: ModelConfig = field(
+        default_factory=ModelConfig
+    )
+
+    _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()
+        return d
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        data = data.copy()
+        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", {})
+        )
+        return cls(
+            **data,
+            redteam_test_configurations=test_configs,
+            dataset_configuration=dataset_config,
+            endpoint_configuration=endpoint_config,
+        )
+
+@dataclass
+class RedTeamCustomConfigWithSavedModel(BaseDTO):
+    test_name: str = "Test Name"
+
+    redteam_test_configurations: RedTeamTestConfigurations = field(
+        default_factory=RedTeamTestConfigurations
+    )
+    dataset_configuration: DatasetConfig = field(
+        default_factory=DatasetConfig
+    )
+
+    _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()
+        return d
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        data = data.copy()
+        test_configs = RedTeamTestConfigurations.from_dict(
+            data.pop("redteam_test_configurations", {})
+        )
+        dataset_config = DatasetConfig.from_dict(
+            data.pop("dataset_configuration", {})
+        )
+        return cls(
+            **data,
+            redteam_test_configurations=test_configs,
+            dataset_configuration=dataset_config,
+        )
+
+
 @dataclass
 class RedTeamTaskList(BaseDTO):
     tasks: List[RedTeamTaskDetails] = field(default_factory=list)
@@ -494,3 +574,6 @@ class RedTeamTaskList(BaseDTO):
 # Default configurations
 DEFAULT_REDTEAM_CONFIG = RedTeamConfig()
 DEFAULT_REDTEAM_CONFIG_WITH_SAVED_MODEL = RedTeamConfigWithSavedModel()
+
+DEFAULT_CUSTOM_REDTEAM_CONFIG = RedTeamCustomConfig()
+DEFAULT_CUSTOM_REDTEAM_CONFIG_WITH_SAVED_MODEL = RedTeamCustomConfigWithSavedModel()

enkryptai_sdk/guardrails.py

@@ -1,3 +1,4 @@
+import os
 # import requests
 from .base import BaseClient
 from .config import GuardrailsConfig
@@ -24,10 +25,12 @@ from .dto import (
     GuardrailsRelevancyResponse,
     # GuardrailsPolicyRequest,
     GuardrailsPolicyData,
-    GuardrailsaPolicyResponse,
+    GuardrailsPolicyResponse,
     # GuardrailsDeletePolicyData,
     GuardrailsDeletePolicyResponse,
     GuardrailsListPoliciesResponse,
+    GuardrailsPolicyAtomizerRequest,
+    GuardrailsPolicyAtomizerResponse,
 )
 
 # ---------------------------------------
@@ -92,7 +95,7 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("GET", "/guardrails/health")
             if response.get("error"):
-                raise GuardrailsClientError(response["error"])
+                raise GuardrailsClientError(f"API Error: {str(response)}")
             return GuardrailsHealthResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
@@ -104,7 +107,7 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("GET", "/guardrails/status")
             if response.get("error"):
-                raise GuardrailsClientError(response["error"])
+                raise GuardrailsClientError(f"API Error: {str(response)}")
             return GuardrailsHealthResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
@@ -116,7 +119,7 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("GET", "/guardrails/models")
             if response.get("error"):
-                raise GuardrailsClientError(response["error"])
+                raise GuardrailsClientError(f"API Error: {str(response)}")
             return GuardrailsModelsResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
@@ -152,7 +155,7 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("POST", "/guardrails/detect", json=payload)
             if response.get("error"):
-                raise GuardrailsClientError(response["error"])
+                raise GuardrailsClientError(f"API Error: {str(response)}")
             return GuardrailsDetectResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
@@ -188,7 +191,7 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("POST", "/guardrails/batch/detect", json=payload)
             if isinstance(response, dict) and response.get("error"):
-                raise GuardrailsClientError(response["error"])
+                raise GuardrailsClientError(f"API Error: {str(response)}")
             return GuardrailsBatchDetectResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
@@ -207,7 +210,7 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("POST", "/guardrails/pii", json=payload)
             if response.get("error"):
-                raise GuardrailsClientError(response["error"])
+                raise GuardrailsClientError(f"API Error: {str(response)}")
             return GuardrailsPIIResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
@@ -225,7 +228,7 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("POST", "/guardrails/hallucination", json=payload)
             if response.get("error"):
-                raise GuardrailsClientError(response["error"])
+                raise GuardrailsClientError(f"API Error: {str(response)}")
             return GuardrailsHallucinationResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
@@ -242,7 +245,7 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("POST", "/guardrails/adherence", json=payload)
             if response.get("error"):
-                raise GuardrailsClientError(response["error"])
+                raise GuardrailsClientError(f"API Error: {str(response)}")
             return GuardrailsAdherenceResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
@@ -259,7 +262,7 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("POST", "/guardrails/relevancy", json=payload)
             if response.get("error"):
-                raise GuardrailsClientError(response["error"])
+                raise GuardrailsClientError(f"API Error: {str(response)}")
             return GuardrailsRelevancyResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
@@ -293,8 +296,8 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("POST", "/guardrails/add-policy", json=payload)
             if response.get("error"):
-                raise GuardrailsClientError(response["error"])
-            return GuardrailsaPolicyResponse.from_dict(response)
+                raise GuardrailsClientError(f"API Error: {str(response)}")
+            return GuardrailsPolicyResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
 
@@ -307,7 +310,7 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("GET", "/guardrails/get-policy", headers=headers)
             if response.get("error"):
-                raise GuardrailsClientError(response["error"])
+                raise GuardrailsClientError(f"API Error: {str(response)}")
             return GuardrailsPolicyData.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
@@ -335,8 +338,8 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("PATCH", "/guardrails/modify-policy", headers=headers, json=payload)
             if response.get("error"):
-                raise GuardrailsClientError(response["error"])
-            return GuardrailsaPolicyResponse.from_dict(response)
+                raise GuardrailsClientError(f"API Error: {str(response)}")
+            return GuardrailsPolicyResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
 
@@ -349,7 +352,7 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("DELETE", "/guardrails/delete-policy", headers=headers)
             if response.get("error"):
-                raise GuardrailsClientError(response["error"])
+                raise GuardrailsClientError(f"API Error: {str(response)}")
             return GuardrailsDeletePolicyResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
@@ -364,7 +367,7 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("POST", "/guardrails/policy/detect", headers=headers, json=payload)
             if response.get("error"):
-                raise GuardrailsClientError(response["error"])
+                raise GuardrailsClientError(f"API Error: {str(response)}")
             return GuardrailsDetectResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
@@ -377,7 +380,69 @@ class GuardrailsClient(BaseClient):
         try:
             response = self._request("GET", "/guardrails/list-policies")
             if isinstance(response, dict) and response.get("error"):
-                raise GuardrailsClientError(response["error"])
+                raise GuardrailsClientError(f"API Error: {str(response)}")
             return GuardrailsListPoliciesResponse.from_dict(response)
         except Exception as e:
             raise GuardrailsClientError(str(e))
+        
+    def atomize_policy(self, file=None, text=None):
+        """
+        Atomize a policy from either a file or text input.
+
+        Parameters:
+        - file (str, optional): Path to the policy file
+        - text (str, optional): Policy text content
+
+        Returns:
+        - GuardrailsPolicyAtomizerResponse
+
+        Raises:
+        - GuardrailsClientError: If validation fails or API returns an error
+        """
+        try:
+            # Create and validate request
+            request = GuardrailsPolicyAtomizerRequest(file=file, text=text)
+            if not request.validate():
+                raise GuardrailsClientError("Invalid request: Must provide either file or text. Not both.")
+
+            # Prepare the request based on input type
+            if file:
+                # Normalize file path and check existence
+                file_path = os.path.abspath(file)
+                file_name = os.path.basename(file_path)
+                print(f"File name: {file_name}")
+                print(f"Reading file: {file_path}")
+
+                if not os.path.exists(file_path):
+                    raise GuardrailsClientError(f"File not found: {file_path}")
+
+                # Check file extension
+                if not file_path.lower().endswith('.pdf'):
+                    raise GuardrailsClientError("Only PDF files are supported")
+                                    
+                with open(file_path, 'rb') as f:
+                    file_content = f.read()
+                    # Create form data with filename
+                    form_data = {
+                        'file': (file_name, file_content, 'application/pdf')
+                    }
+                    response = self._request(
+                        "POST", 
+                        "/guardrails/policy-atomizer", 
+                        form_data=form_data
+                    )
+            else:
+                form_data = {'text': text}
+                response = self._request(
+                    "POST", 
+                    "/guardrails/policy-atomizer", 
+                    form_data=form_data
+                )
+
+            if isinstance(response, dict) and response.get("error"):
+                raise GuardrailsClientError(f"API Error: {str(response)}")
+                
+            return GuardrailsPolicyAtomizerResponse.from_dict(response)
+        except Exception as e:
+            raise GuardrailsClientError(str(e))
+

enkryptai_sdk/models.py

@@ -15,18 +15,20 @@ class ModelClient(BaseClient):
     def __init__(self, api_key: str, base_url: str = "https://api.enkryptai.com:443"):
         super().__init__(api_key, base_url)
 
-    def add_model(self, config: ModelConfig) -> ModelResponse:
+    @staticmethod
+    def prepare_model_payload(config: ModelConfig | dict, is_custom: bool = False) -> dict:
         """
-        Add a new model configuration to the system.
-
+        Prepare the payload for model operations from a config object.
+        
         Args:
-            config (ModelConfig): Configuration object containing model details
-
+            config (Union[ModelConfig, dict]): Configuration object or dictionary containing model details
+            
         Returns:
-            dict: Response from the API containing the added model details
+            dict: Processed payload ready for API submission
         """
-        headers = {"Content-Type": "application/json"}
-        config = ModelConfig.from_dict(config)
+        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("/")
@@ -43,15 +45,11 @@ class ModelClient(BaseClient):
             paths = config.model_config.paths.to_dict()
         else:
             paths = {
-                "completions": (
-                    f"/{remaining_path.split('/')[-1]}" if remaining_path else ""
-                ),
+                "completions": f"/{remaining_path.split('/')[-1]}" if remaining_path else "",
                 "chat": f"/{remaining_path}" if remaining_path else "",
             }
 
         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,
@@ -63,9 +61,8 @@ class ModelClient(BaseClient):
                 "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
+                    "port": parsed_url.port or (443 if parsed_url.scheme == "https" else 80),
+                    "base_path": f"/{base_path}",
                 },
                 "paths": paths,
                 "auth_data": {
@@ -73,9 +70,7 @@ class ModelClient(BaseClient):
                     "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 []
-                ),
+                "apikeys": [config.model_config.apikey] if config.model_config.apikey else [],
                 "tools": config.model_config.tools,
                 "input_modalities": config.model_config.input_modalities,
                 "output_modalities": config.model_config.output_modalities,
@@ -87,12 +82,32 @@ class ModelClient(BaseClient):
                 "default_request_options": config.model_config.default_request_options,
             },
         }
+
+        if not is_custom:
+            payload["model_saved_name"] = config.model_saved_name
+            payload["model_version"] = config.model_version
+
+        return payload
+
+    def add_model(self, config: ModelConfig) -> ModelResponse:
+        """
+        Add a new model configuration to the system.
+
+        Args:
+            config (ModelConfig): Configuration object containing model details
+
+        Returns:
+            dict: Response from the API containing the added model details
+        """
+        headers = {"Content-Type": "application/json"}
+        payload = self.prepare_model_payload(config)
+
         try:
             response = self._request(
                 "POST", "/models/add-model", headers=headers, json=payload
             )
             if response.get("error"):
-                raise ModelClientError(response["error"])
+                raise ModelClientError(f"API Error: {str(response)}")
             return ModelResponse.from_dict(response)
         except Exception as e:
             raise ModelClientError(str(e))
@@ -112,7 +127,7 @@ class ModelClient(BaseClient):
         response = self._request("GET", "/models/get-model", headers=headers)
         # print(response)
         if response.get("error"):
-            raise ModelClientError(response["error"])
+            raise ModelClientError(f"API Error: {str(response)}")
         return ModelConfig.from_dict(response)
 
     def get_model_list(self):
@@ -125,7 +140,7 @@ class ModelClient(BaseClient):
         try:
             response = self._request("GET", "/models/list-models")
             if isinstance(response, dict) and response.get("error"):
-                raise ModelClientError(response["error"])
+                raise ModelClientError(f"API Error: {str(response)}")
             return ModelCollection.from_dict(response)
         except Exception as e:
             return {"error": str(e)}
@@ -217,7 +232,7 @@ class ModelClient(BaseClient):
                 "PATCH", "/models/modify-model", headers=headers, json=payload
             )
             if response.get("error"):
-                raise ModelClientError(response["error"])
+                raise ModelClientError(f"API Error: {str(response)}")
             return ModelResponse.from_dict(response)
         except Exception as e:
             raise ModelClientError(str(e))
@@ -238,7 +253,7 @@ class ModelClient(BaseClient):
         try:
             response = self._request("DELETE", "/models/delete-model", headers=headers)
             if response.get("error"):
-                raise ModelClientError(response["error"])
+                raise ModelClientError(f"API Error: {str(response)}")
             return ModelResponse.from_dict(response)
         except Exception as e:
             raise ModelClientError(str(e))