     public func discoverIncludedServices(
         _ services: Set<BluetoothUUID> = [],
         for service: Service<Peripheral, AttributeID>
-    ) -> AsyncThrowingStream<Service<Peripheral, AttributeID>, Error> {
+    ) async throws -> [Service<Peripheral, AttributeID>] {
         let serviceUUIDs = services.isEmpty ? nil : services.map { CBUUID($0) }
-        return AsyncThrowingStream(Service<Peripheral, AttributeID>.self, bufferingPolicy: .unbounded) { [weak self] continuation in
+        return try await withCheckedThrowingContinuation { [weak self] continuation in
             guard let self = self else { return }
             self.queue.async {
                 let peripheral = service.peripheral
                 // get peripheral
                 guard let peripheralObject = self.cache.peripherals[peripheral] else {
-                    continuation.finish(throwing: CentralError.unknownPeripheral)
+                    continuation.resume(throwing: CentralError.unknownPeripheral)
                     return
                 }
                 // get service
                 guard let serviceObject = self.cache.services[service] else {
-                    continuation.finish(throwing: CentralError.invalidAttribute(service.uuid))
+                    continuation.resume(throwing: CentralError.invalidAttribute(service.uuid))
                     return
                 }
                 // check power on
                 let state = self.centralManager._state
                 guard state == .poweredOn else {
-                    continuation.finish(throwing: DarwinCentralError.invalidState(state))
+                    continuation.resume(throwing: DarwinCentralError.invalidState(state))
                     return
                 }
                 // check connected
                 guard peripheralObject.state == .connected else {
-                    continuation.finish(throwing: CentralError.disconnected)
+                    continuation.resume(throwing: CentralError.disconnected)
                     return
                 }
                 // cancel old task
                 if let oldTask = self.continuation.discoverIncludedServices[service] {
-                    oldTask.finish(throwing: CancellationError())
+                    oldTask.resume(throwing: CancellationError())
                     self.continuation.discoverIncludedServices[service] = nil
                 }
                 // discover

                return
            }
            if let error = error {
                continuation.finish(throwing: error)
            } else {
                for characteristicObject in (serviceObject.characteristics ?? []) {
                    let characteristic = Characteristic(
                        characteristic: characteristicObject,
                        peripheral: peripheralObject
                    )
                    continuation.yield(characteristic)
                }
                continuation.finish(throwing: nil)
            }
            // remove callback
            self.central.continuation.discoverCharacteristics[peripheral] = nil

                }
                // cancel old task
                if let oldTask = self.continuation.discoverCharacteristics[peripheral] {
                    oldTask.resume(throwing: CancellationError())
                    self.continuation.discoverCharacteristics[peripheral] = nil
                }
                // notify
