                 return
             }
             if let error = error {
-                continuation.finish(throwing: error)
+                continuation.resume(throwing: error)
             } else {
-                for serviceObject in (serviceObject.includedServices ?? []) {
-                    let service = Service(
+                let services = (serviceObject.includedServices ?? []).map { serviceObject in
+                    Service(
                         service: serviceObject,
                         peripheral: peripheralObject
                     )
-                    continuation.yield(service)
-                }
-                continuation.finish(throwing: nil)
+                }
+                continuation.resume(returning: services)
             }
             // remove callback
             self.central.continuation.discoverIncludedServices[service] = nil

    public func discoverIncludedServices(
        _ services: Set<BluetoothUUID> = [],
        for service: Service<Peripheral, AttributeID>
    ) -> AsyncThrowingStream<Service<Peripheral, AttributeID>, Error> {
        let serviceUUIDs = services.isEmpty ? nil : services.map { CBUUID($0) }
        return AsyncThrowingStream(Service<Peripheral, AttributeID>.self, bufferingPolicy: .unbounded) { [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)
                    return
                }
                // get service
                guard let serviceObject = self.cache.services[service] else {
                    continuation.finish(throwing: CentralError.invalidAttribute(service.uuid))
                    return
                }
                // check power on
                let state = self.centralManager._state
                guard state == .poweredOn else {
                    continuation.finish(throwing: DarwinCentralError.invalidState(state))
                    return
                }
                // check connected
                guard peripheralObject.state == .connected else {
                    continuation.finish(throwing: CentralError.disconnected)
                    return
                }
                // cancel old task
                if let oldTask = self.continuation.discoverIncludedServices[service] {
                    oldTask.finish(throwing: CancellationError())
                    self.continuation.discoverIncludedServices[service] = nil
                }
                // discover

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