const messagesHandler: IMessagesHandler = {
          handleOutgoingMessage: (message: string) => {
            if (!apiService) {
              throw new Error("apiService is not initialized");
            }
            // Send the message to the backend server
            return apiService.sendMessage(deviceId, message);
          },
        };

// create your own implementation of the FireblocksMessageHandler and pass it in the Fireblocks.initialize method
val fireblocksMessageHandler = FireblocksMessageHandlerImpl()

// An implementation example for the FireblocksMessageHandler. 
// Override the handleOutgoingMessage method and call pass the payload to Fireblocks BE using your BE implementation. 
// Make sure you to invoke the responseCallback with the response body or the errorCallback in case of an error
class FireblocksMessageHandlerImpl(
private val context: Context, 
private val deviceId: String) 
: FireblocksMessageHandler, CoroutineScope {
    private val job = Job()
    override val coroutineContext: CoroutineContext
        get() = Dispatchers.IO + job

    override fun handleOutgoingMessage(
payload:String,
responseCallback: (responseBody: String?) -> Unit,
      errorCallback: (errorMessage: String?) -> Unit) {
        runBlocking {
            withContext(Dispatchers.IO) {
                // do rest API call
                Timber.i("calling invoke rest API")
                runCatching {
                    val response = Api.with(StorageManager.get(context, deviceId)).invoke(deviceId, MessageBody(payload)).execute()
                    Timber.i("got response from invoke rest API, code:${response.code()}, isSuccessful:${response.isSuccessful}")
                    responseCallback(response.body())
                }.onFailure {
                    Timber.e(it, "Failed to call invoke Api")
                    errorCallback("Failed to call invoke Api")
                }
            }
        }
    }
}

extension DeviceInstance: MessageHandlerDelegate {
    func handleOutgoingMessage(payload: String, response: @escaping (String?) -> (), error: @escaping (String?) -> ()) {
        sessionManager.rpc(deviceId: deviceId, message: payload) { response in
            //handle response
        } error: { error in
            //handle error
        }
    }
}