pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/assistant/managers.py

@@ -1,5 +1,5 @@
 from typing import Any
-import sys
+from pygeai import logger
 from pygeai.assistant.clients import AssistantClient
 from pygeai.assistant.rag.clients import RAGAssistantClient
 from pygeai.assistant.rag.mappers import RAGAssistantMapper
@@ -15,12 +15,12 @@ from pygeai.core.feedback.models import FeedbackRequest
 from pygeai.core.responses import NewAssistantResponse, ChatResponse
 from pygeai.chat.clients import ChatClient
 from pygeai.assistant.rag.models import RAGAssistant, Document, UploadDocument
-from pygeai.core.common.exceptions import MissingRequirementException
+from pygeai.core.common.exceptions import MissingRequirementException, APIError
 
 
 class AssistantManager:
 
-    def __init__(self, api_key: str = None, base_url: str = None, alias: str = "default"):
+    def __init__(self, api_key: str = None, base_url: str = None, alias: str = None):
         self.__assistant_client = AssistantClient(api_key, base_url, alias)
         self.__chat_client = ChatClient(api_key, base_url, alias)
         self.__rag_client = RAGAssistantClient(api_key, base_url, alias)
@@ -68,25 +68,25 @@ class AssistantManager:
         Retrieves detailed data for a specific assistant.
 
         This method calls `AssistantClient.get_assistant_data` to fetch assistant details
-        and maps the response using `AssistantResponseMapper.map_to_assistant_list_response`.
-
-        If the response contains errors, they are processed using `ErrorMapper` to return an `ErrorListResponse`.
+        and maps the response using `AssistantResponseMapper.map_to_assistant_response`.
 
         :param assistant_id: str - The unique identifier of the assistant to retrieve.
         :param detail: str, optional - The level of detail to include in the response. Possible values:
             - "summary": Provides a summarized response. (Default)
             - "full": Provides detailed assistant data.
-        :return: AssistantResponse - The mapped response containing assistant details or an error list.
+        :return: Assistant - The mapped response containing assistant details.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__assistant_client.get_assistant_data(
             assistant_id=assistant_id,
             detail=detail
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = AssistantResponseMapper.map_to_assistant_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while retrieving assistant data by ID: {error}")
+            raise APIError(f"Error received while retrieving assistant data by ID: {error}")
 
+        result = AssistantResponseMapper.map_to_assistant_response(response_data)
         return result
 
     def _get_assistant_data_by_name(self, assistant_name: str) -> RAGAssistant:
@@ -96,19 +96,19 @@ class AssistantManager:
         This method calls `RAGAssistantClient.get_assistant_data` to fetch assistant details
         and maps the response using `RAGAssistantMapper.map_to_rag_assistant`.
 
-        If the response contains errors, they are processed using `ErrorMapper` to return an `ErrorListResponse`.
-
         :param assistant_name: str - The name of the assistant to retrieve.
-        :return: RAGAssistant - The mapped response containing assistant details or an error list.
+        :return: RAGAssistant - The mapped response containing assistant details.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__rag_client.get_assistant_data(
             name=assistant_name
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = RAGAssistantMapper.map_to_rag_assistant(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while retrieving assistant data by name: {error}")
+            raise APIError(f"Error received while retrieving assistant data by name: {error}")
 
+        result = RAGAssistantMapper.map_to_rag_assistant(response_data)
         return result
 
     def create_assistant(
@@ -141,26 +141,46 @@ class AssistantManager:
             self,
             assistant: Assistant
     ) -> NewAssistantResponse:
+        """
+        Creates a new chat assistant.
+
+        This method calls `AssistantClient.create_assistant` to create a new assistant
+        and maps the response using `AssistantResponseMapper.map_to_assistant_created_response`.
+
+        :param assistant: Assistant - The assistant instance to be created.
+        :return: NewAssistantResponse - The mapped response containing the created assistant details.
+        :raises APIError: If the API returns errors.
+        """
         response_data = self.__assistant_client.create_assistant(
             assistant_type=assistant.type,
             name=assistant.name,
             prompt=assistant.prompt,
             description=assistant.description,
-            llm_settings=assistant.llm_settings.to_dict(),
-            welcome_data=assistant.welcome_data.to_dict()
+            llm_settings=assistant.llm_settings.to_dict() if assistant.llm_settings else None,
+            welcome_data=assistant.welcome_data.to_dict() if assistant.welcome_data else None
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = AssistantResponseMapper.map_to_assistant_created_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while creating chat assistant: {error}")
+            raise APIError(f"Error received while creating chat assistant: {error}")
 
+        result = AssistantResponseMapper.map_to_assistant_created_response(response_data)
         return result
 
     def _create_rag_assistant(
             self,
             assistant: RAGAssistant
     ) -> RAGAssistant:
+        """
+        Creates a new RAG assistant.
+
+        This method calls `RAGAssistantClient.create_assistant` to create a new assistant
+        and maps the response using `RAGAssistantMapper.map_to_rag_assistant`.
 
+        :param assistant: RAGAssistant - The assistant instance to be created.
+        :return: RAGAssistant - The mapped response containing the created assistant details.
+        :raises APIError: If the API returns errors.
+        """
         response_data = self.__rag_client.create_assistant(
             name=assistant.name,
             description=assistant.description,
@@ -170,16 +190,27 @@ class AssistantManager:
             welcome_data=assistant.welcome_data.to_dict() if assistant.welcome_data else None
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = RAGAssistantMapper.map_to_rag_assistant(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while creating RAG assistant: {error}")
+            raise APIError(f"Error received while creating RAG assistant: {error}")
 
+        result = RAGAssistantMapper.map_to_rag_assistant(response_data)
         return result
 
     def _create_chat_with_data_assistant(
             self,
             assistant: ChatWithDataAssistant
     ) -> NewAssistantResponse:
+        """
+        Creates a new chat with data assistant.
+
+        This method calls `AssistantClient.create_assistant` to create a new assistant
+        and maps the response using `AssistantResponseMapper.map_to_assistant_created_response`.
+
+        :param assistant: ChatWithDataAssistant - The assistant instance to be created.
+        :return: NewAssistantResponse - The mapped response containing the created assistant details.
+        :raises APIError: If the API returns errors.
+        """
         response_data = self.__assistant_client.create_assistant(
             assistant_type=assistant.type,
             name=assistant.name,
@@ -189,10 +220,11 @@ class AssistantManager:
             welcome_data=assistant.welcome_data.to_dict()
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = AssistantResponseMapper.map_to_assistant_created_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while creating chat with data assistant: {error}")
+            raise APIError(f"Error received while creating chat with data assistant: {error}")
 
+        result = AssistantResponseMapper.map_to_assistant_created_response(response_data)
         return result
 
     def update_assistant(
@@ -202,25 +234,25 @@ class AssistantManager:
             revision_id: str = None
     ) -> Any:
         """
-       Updates an assistant based on its type.
-
-       This method determines the assistant type and delegates the update process accordingly:
-       - Calls `_update_chat_assistant` for `TextAssistant` or `ChatAssistant`.
-       - Calls `_update_rag_assistant` for `RAGAssistant`.
-
-       :param assistant: Assistant - The assistant instance to be updated.
-       :param action: str, optional - The type of update action for chat-based assistants. Options:
-           - "save": Updates an existing revision (requires `revision_id`).
-           - "saveNewRevision" (default): Creates and saves a new revision.
-           - "savePublishNewRevision": Creates, saves, and publishes a new revision.
-       :param revision_id: str, optional - The ID of the existing revision to update.
-           Required if `action` is "save". Must be None for "saveNewRevision" or "savePublishNewRevision".
-       :return: Any - The updated assistant instance or an error response if the update fails.
-       :raises ValueError: If `action` is not a valid option.
-       :raises MissingRequirementException:
-           - If `action` is "save" and `revision_id` is not provided.
-           - If `revision_id` is provided for "saveNewRevision" or "savePublishNewRevision".
-       """
+        Updates an assistant based on its type.
+
+        This method determines the assistant type and delegates the update process accordingly:
+        - Calls `_update_chat_assistant` for `TextAssistant` or `ChatAssistant`.
+        - Calls `_update_rag_assistant` for `RAGAssistant`.
+
+        :param assistant: Assistant - The assistant instance to be updated.
+        :param action: str, optional - The type of update action for chat-based assistants. Options:
+            - "save": Updates an existing revision (requires `revision_id`).
+            - "saveNewRevision" (default): Creates and saves a new revision.
+            - "savePublishNewRevision": Creates, saves, and publishes a new revision.
+        :param revision_id: str, optional - The ID of the existing revision to update.
+            Required if `action` is "save". Must be None for "saveNewRevision" or "savePublishNewRevision".
+        :return: Any - The updated assistant instance or an error response if the update fails.
+        :raises ValueError: If `action` is not a valid option.
+        :raises MissingRequirementException:
+            - If `action` is "save" and `revision_id` is not provided.
+            - If `revision_id` is provided for "saveNewRevision" or "savePublishNewRevision".
+        """
         if isinstance(assistant, TextAssistant) or isinstance(assistant, ChatAssistant):
             return self._update_chat_assistant(assistant=assistant, action=action, revision_id=revision_id)
         elif isinstance(assistant, RAGAssistant):
@@ -229,16 +261,14 @@ class AssistantManager:
     def _update_chat_assistant(
             self,
             assistant: Assistant,
-            action: str = "saveNewRevision",  # "save", "saveNewRevision", "savePublishNewRevision"
+            action: str = "saveNewRevision",
             revision_id: str = None
     ) -> NewAssistantResponse:
         """
         Updates an assistant with a specified action.
 
-        This method calls `AssistantClient.update_assistant` to update the assistant and maps the response
-        using `AssistantResponseMapper.map_to_assistant_created_response`.
-
-        If the response contains errors, they are processed using `ErrorMapper` to return an `ErrorListResponse`.
+        This method calls `AssistantClient.update_assistant` to update the assistant
+        and maps the response using `AssistantResponseMapper.map_to_assistant_created_response`.
 
         :param assistant: Assistant - The assistant instance containing updated details.
         :param action: str - The type of update action. Options:
@@ -247,11 +277,12 @@ class AssistantManager:
             - "savePublishNewRevision": Creates, saves, and publishes a new revision.
         :param revision_id: str, optional - The ID of the existing revision to update.
             Required if `action` is "save". Must be None for "saveNewRevision" or "savePublishNewRevision".
-        :return: NewAssistantResponse - A response object containing the updated assistant details or an error list if the request fails.
+        :return: NewAssistantResponse - A response object containing the updated assistant details.
         :raises ValueError: If `action` is not one of the valid options.
         :raises MissingRequirementException:
             - If `action` is "save" and `revision_id` is not provided.
             - If `revision_id` is provided for "saveNewRevision" or "savePublishNewRevision".
+        :raises APIError: If the API returns errors.
         """
         if action not in ["save", "saveNewRevision", "savePublishNewRevision"]:
             raise ValueError("Valid actions are: 'save', 'saveNewRevision', 'savePublishNewRevision'")
@@ -266,6 +297,11 @@ class AssistantManager:
                 "Assistant prompt is required if revisionId is specified or in case of actions saveNewRevision and savePublishNewRevision"
             )
 
+        if not assistant.id:
+            raise MissingRequirementException(
+                "Assistant must have a valid ID in order to be able to be updated."
+            )
+
         response_data = self.__assistant_client.update_assistant(
             assistant_id=assistant.id,
             status=assistant.status,
@@ -274,15 +310,16 @@ class AssistantManager:
             name=assistant.name,
             prompt=assistant.prompt,
             description=assistant.description,
-            llm_settings=assistant.llm_settings.to_dict(),
-            welcome_data=assistant.welcome_data.to_dict()
+            llm_settings=assistant.llm_settings.to_dict() if assistant.llm_settings else None,
+            welcome_data=assistant.welcome_data.to_dict() if assistant.welcome_data else None
         )
 
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = AssistantResponseMapper.map_to_assistant_created_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while updating chat assistant: {error}")
+            raise APIError(f"Error received while updating chat assistant: {error}")
 
+        result = AssistantResponseMapper.map_to_assistant_created_response(response_data)
         return result
 
     def _update_rag_assistant(
@@ -292,14 +329,12 @@ class AssistantManager:
         """
         Updates an existing RAGAssistant instance.
 
-        This method calls `RAGAssistantClient.update_assistant` to update the assistant details and maps the response
-        using `RAGAssistantMapper.map_to_rag_assistant`.
-
-        If the response contains errors, they are processed using `ErrorMapper` to return an `ErrorListResponse`.
+        This method calls `RAGAssistantClient.update_assistant` to update the assistant details
+        and maps the response using `RAGAssistantMapper.map_to_rag_assistant`.
 
         :param assistant: RAGAssistant - The assistant instance containing updated details.
-        :return: RAGAssistant - The updated RAGAssistant instance if the update is successful, or an error-mapped response if the request fails.
-        :raises Exception: If the update request encounters unexpected errors.
+        :return: RAGAssistant - The updated RAGAssistant instance.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__rag_client.update_assistant(
             name=assistant.name,
@@ -310,10 +345,11 @@ class AssistantManager:
             welcome_data=assistant.welcome_data.to_dict() if assistant.welcome_data else None
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = RAGAssistantMapper.map_to_rag_assistant(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while updating RAG assistant: {error}")
+            raise APIError(f"Error received while updating RAG assistant: {error}")
 
+        result = RAGAssistantMapper.map_to_rag_assistant(response_data)
         return result
 
     def delete_assistant(
@@ -334,7 +370,7 @@ class AssistantManager:
         :param assistant_id: str, optional - The unique identifier of the assistant to delete.
         :param assistant_name: str, optional - The name of the assistant to delete.
         :raises MissingRequirementException: If neither `assistant_id` nor `assistant_name` is provided.
-        :return: EmptyResponse - A response indicating success or an error list if the deletion fails.
+        :return: EmptyResponse - A response indicating success.
         """
         if not (assistant_id or assistant_name):
             raise MissingRequirementException("Cannot delete assistant without either assistant_id or assistant_name")
@@ -351,22 +387,22 @@ class AssistantManager:
         """
         Deletes an assistant by its unique identifier.
 
-        This method calls `AssistantClient.delete_assistant` to remove an assistant and maps the response
-        using `ResponseMapper.map_to_empty_response`.
-
-        If the response contains errors, they are processed using `ErrorMapper` to return an `ErrorListResponse`.
+        This method calls `AssistantClient.delete_assistant` to remove an assistant
+        and maps the response using `ResponseMapper.map_to_empty_response`.
 
         :param assistant_id: str - The unique identifier of the assistant to be deleted.
-        :return: EmptyResponse - An empty response indicating successful deletion or an error list if the request fails.
+        :return: EmptyResponse - An empty response indicating successful deletion.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__assistant_client.delete_assistant(
             assistant_id=assistant_id
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = ResponseMapper.map_to_empty_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while deleting assistant by ID: {error}")
+            raise APIError(f"Error received while deleting assistant by ID: {error}")
 
+        result = ResponseMapper.map_to_empty_response(response_data or "Assistant deleted successfully")
         return result
 
     def _delete_assistant_by_name(
@@ -379,19 +415,19 @@ class AssistantManager:
         This method calls `RAGAssistantClient.delete_assistant` to remove the assistant
         and maps the response using `ResponseMapper.map_to_empty_response`.
 
-        If the response contains errors, they are processed using `ErrorMapper` to return an `ErrorListResponse`.
-
         :param assistant_name: str - The name of the assistant to be deleted.
-        :return: EmptyResponse - A response indicating success or an error list if the deletion fails.
+        :return: EmptyResponse - A response indicating success.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__rag_client.delete_assistant(
             name=assistant_name
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = ResponseMapper.map_to_empty_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while deleting assistant by name: {error}")
+            raise APIError(f"Error received while deleting assistant by name: {error}")
 
+        result = ResponseMapper.map_to_empty_response(response_data or "Assistant deleted successfully")
         return result
 
     def send_chat_request(
@@ -405,16 +441,14 @@ class AssistantManager:
         Sends a chat request to the assistant and processes the response.
 
         This method sends a conversation request to an AI assistant, including a list of chat messages,
-        an optional revision identifier, and optional chat variables. It then maps the response to
-        either an error list or a structured chat response.
+        an optional revision identifier, and optional chat variables.
 
         :param assistant: Assistant - The assistant instance handling the request.
         :param messages: ChatMessageList - The list of messages forming the chat history.
         :param revision: AssistantRevision, optional - The assistant revision details (default: None).
         :param variables: ChatVariableList, optional - Additional variables for the chat request (default: None).
-
-        :return: ChatResponse - The structured response from the assistant, either a chat response
-                 or an error list.
+        :return: ChatResponse - The structured response from the assistant.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__assistant_client.send_chat_request(
             assistant_name=assistant.name,
@@ -424,10 +458,11 @@ class AssistantManager:
             variables=variables.to_list() if variables else None
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = AssistantResponseMapper.map_to_chat_request_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while sending chat request: {error}")
+            raise APIError(f"Error received while sending chat request: {error}")
 
+        result = AssistantResponseMapper.map_to_chat_request_response(response_data)
         return result
 
     def get_request_status(self, request_id: str) -> ChatResponse:
@@ -435,45 +470,42 @@ class AssistantManager:
         Retrieves the status of a chat request using the provided request ID.
 
         This method queries the assistant service to check the current status of a
-        previously sent chat request. It then processes the response, mapping it to either
-        a structured chat response or an error list if any issues are found.
+        previously sent chat request.
 
         :param request_id: str - The unique identifier of the chat request.
-
-        :return: ChatResponse - The structured response containing the request status, or
-                 an error list if the request failed.
+        :return: ChatResponse - The structured response containing the request status.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__assistant_client.get_request_status(
             request_id=request_id
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = AssistantResponseMapper.map_to_chat_request_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while retrieving request status: {error}")
+            raise APIError(f"Error received while retrieving request status: {error}")
 
+        result = AssistantResponseMapper.map_to_chat_request_response(response_data)
         return result
 
     def cancel_request(self, request_id: str) -> ChatResponse:
         """
         Cancels an ongoing chat request using the provided request ID.
 
-        This method sends a cancellation request to the assistant service. If the request
-        is successfully canceled, it returns a structured chat response. If there are
-        errors, it maps them to an error list response.
+        This method sends a cancellation request to the assistant service.
 
         :param request_id: str - The unique identifier of the chat request to cancel.
-
-        :return: ChatResponse - The structured response confirming the cancellation,
-                 or an error list if the cancellation fails.
+        :return: ChatResponse - The structured response confirming the cancellation.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__assistant_client.cancel_request(
             request_id=request_id
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = AssistantResponseMapper.map_to_chat_request_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while canceling request: {error}")
+            raise APIError(f"Error received while canceling request: {error}")
 
+        result = AssistantResponseMapper.map_to_chat_request_response(response_data)
         return result
 
     def chat_completion(
@@ -485,13 +517,12 @@ class AssistantManager:
             variables: ChatVariableList = None,
             tool_choice: ToolChoice = None,
             tools: ChatToolList = None
-    ):
+    ) -> ChatResponse:
         """
         Generates a chat completion response using the specified language model.
 
         This method sends a chat completion request to the ChatClient with the provided
-        model, messages, and settings. It processes the response by mapping errors if
-        present or converting it into an assistant response format.
+        model, messages, and settings.
 
         :param model: str - The identifier of the language model to use.
         :param messages: ChatMessageList - A list of chat messages to provide context for the completion.
@@ -501,9 +532,8 @@ class AssistantManager:
         :param variables: ChatVariableList, optional - Additional variables to include in the request.
         :param tool_choice: ToolChoice, optional - Indicates which tool to call.
         :param tools: ChatToolList, optional - Additional tools the model may call
-
-        :return: ChatResponse - The structured chat response if successful,
-                 or an error list if an issue occurs.
+        :return: ChatResponse - The structured chat response.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__chat_client.chat_completion(
             model=model,
@@ -520,10 +550,11 @@ class AssistantManager:
         )
 
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = AssistantResponseMapper.map_to_provider_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while generating chat completion: {error}")
+            raise APIError(f"Error received while generating chat completion: {error}")
 
+        result = AssistantResponseMapper.map_to_provider_response(response_data)
         return result
 
     def get_document_list(
@@ -535,13 +566,14 @@ class AssistantManager:
         """
         Retrieves a list of documents associated with a specified RAG assistant.
 
+        This method queries the RAG client to fetch a list of documents for the given assistant name,
+        applying pagination parameters.
+
         :param name: str - The name of the RAG assistant.
         :param skip: int - The number of documents to skip (default: 0).
         :param count: int - The number of documents to retrieve (default: 10).
-
-        :return: DocumentListResponse - A response object containing the retrieved documents or an error response.
-
-        :raises Exception: If the API call encounters errors, they will be mapped using ErrorMapper.
+        :return: DocumentListResponse - A response object containing the retrieved documents.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__rag_client.get_documents(
             name=name,
@@ -550,10 +582,11 @@ class AssistantManager:
         )
 
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = RAGAssistantMapper.map_to_document_list_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while retrieving document list: {error}")
+            raise APIError(f"Error received while retrieving document list: {error}")
 
+        result = RAGAssistantMapper.map_to_document_list_response(response_data)
         return result
 
     def delete_all_documents(
@@ -563,21 +596,22 @@ class AssistantManager:
         """
         Deletes all documents associated with a specified RAG assistant.
 
-        :param name: str - The name of the RAG assistant whose documents should be deleted.
-
-        :return: EmptyResponse - A response object indicating the success or failure of the operation.
+        This method sends a request to the RAG client to delete all documents for the given assistant name.
 
-        :raises Exception: If the API call encounters errors, they will be mapped using ErrorMapper.
+        :param name: str - The name of the RAG assistant whose documents should be deleted.
+        :return: EmptyResponse - A response object indicating the success of the operation.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__rag_client.delete_all_documents(
             name=name
         )
 
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = ResponseMapper.map_to_empty_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while deleting all documents: {error}")
+            raise APIError(f"Error received while deleting all documents: {error}")
 
+        result = ResponseMapper.map_to_empty_response(response_data or "All documents deleted successfully")
         return result
 
     def get_document(
@@ -588,12 +622,13 @@ class AssistantManager:
         """
         Retrieves a specific document associated with a RAG assistant.
 
+        This method sends a request to the RAG client to retrieve a document identified by its ID
+        for the given assistant name.
+
         :param name: str - The name of the RAG assistant.
         :param document_id: str - The unique identifier of the document to retrieve.
-
-        :return: DocumentResponse - A response object containing the retrieved document or an error response.
-
-        :raises Exception: If the API call encounters errors, they will be mapped using ErrorMapper.
+        :return: Document - The retrieved document instance.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__rag_client.retrieve_document(
             name=name,
@@ -601,10 +636,11 @@ class AssistantManager:
         )
 
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = RAGAssistantMapper.map_to_document(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while retrieving document: {error}")
+            raise APIError(f"Error received while retrieving document: {error}")
 
+        result = RAGAssistantMapper.map_to_document(response_data)
         return result
 
     def upload_document(
@@ -615,16 +651,16 @@ class AssistantManager:
         """
         Uploads a document to the specified RAG assistant.
 
+        This method sends a request to the RAG client to upload a document for the given assistant.
+
         :param assistant: RAGAssistant - The assistant to which the document will be uploaded.
         :param document: UploadDocument - The document object containing:
             - path (str): The file path of the document.
             - upload_type (str): The type of upload (e.g., "multipart" or "binary").
             - metadata (dict | str | None): Additional metadata, either as a dictionary or a file path.
             - content_type (str): The MIME type of the document (e.g., "application/pdf", "text/plain").
-
         :return: Document - The uploaded document instance.
-
-        :raises ValueError: If an error occurs during the upload, it is mapped using ErrorMapper.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__rag_client.upload_document(
             name=assistant.name,
@@ -635,10 +671,11 @@ class AssistantManager:
         )
 
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = RAGAssistantMapper.map_to_document(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while uploading document: {error}")
+            raise APIError(f"Error received while uploading document: {error}")
 
+        result = RAGAssistantMapper.map_to_document(response_data)
         return result
 
     def delete_document(
@@ -649,12 +686,13 @@ class AssistantManager:
         """
         Deletes a specific document from the given RAG assistant.
 
+        This method sends a request to the RAG client to delete a document identified by its ID
+        for the given assistant name.
+
         :param name: str - The name of the RAG assistant from which the document will be deleted.
         :param document_id: str - The unique identifier of the document to be deleted.
-
-        :return: EmptyResponse - An empty response object indicating success or failure.
-
-        :raises ValueError: If an error occurs during deletion, it is mapped using ErrorMapper.
+        :return: EmptyResponse - An empty response object indicating success.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__rag_client.delete_document(
             name=name,
@@ -662,10 +700,11 @@ class AssistantManager:
         )
 
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = ResponseMapper.map_to_empty_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while deleting document: {error}")
+            raise APIError(f"Error received while deleting document: {error}")
 
+        result = ResponseMapper.map_to_empty_response(response_data or "Document deleted successfully")
         return result
 
     def send_feedback(
@@ -676,14 +715,11 @@ class AssistantManager:
         Sends feedback for an assistant's response.
 
         This method submits user feedback to the Feedback API using the provided `FeedbackRequest` object.
-        The feedback includes a request identifier, origin, answer score, and an optional comment.
-        If the API response contains errors, they are processed and returned as an `ErrorListResponse`.
-        Otherwise, an `EmptyResponse` is returned.
 
         :param feedback_request: FeedbackRequest - The feedback details, including request ID, origin,
             answer score, and optional comments.
-        :return: EmptyResponse | ErrorListResponse - The processed API response. Returns an `EmptyResponse`
-            if successful or an `ErrorListResponse` if errors occur.
+        :return: EmptyResponse - The processed API response indicating success.
+        :raises APIError: If the API returns errors.
         """
         response_data = self.__feedback_client.send_feedback(
             request_id=feedback_request.request_id,
@@ -693,8 +729,10 @@ class AssistantManager:
         )
 
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = ResponseMapper.map_to_empty_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while sending feedback: {error}")
+            raise APIError(f"Error received while sending feedback: {error}")
 
+        result = ResponseMapper.map_to_empty_response(response_data or "Feedback sent successfully")
         return result
+