     queue: DispatchQueue? = nil,
     responseSerializer: Serializer
   )
-    -> Single<DownloadResponse<Serializer.SerializedObject>>
+    -> Observable<DownloadResponse<Serializer.SerializedObject>>
   {
-    return Single.create { cb in
+    return Observable.create { observer in
       let request = self.base.response(
         queue: queue,
         responseSerializer: responseSerializer
-      ) {
-        cb(.success($0))
+      ) { response in
+        if let error = response.error {
+          observer.onError(error)
+        } else {
+          observer.onNext(response)
+          observer.onCompleted()
+        }
       }
-        
       return Disposables.create(with: request.cancel)
     }
   }

    queue: DispatchQueue? = nil,
    responseSerializer: Serializer
  )
    -> Single<Serializer.SerializedObject>
  {
    return responseSerialized(queue: queue, responseSerializer: responseSerializer)
      .flatMap { response -> Single<Serializer.SerializedObject> in
        switch response.result {
        case .success(let r):   return .just(r)
        case .failure(let e):   return .error(e)
        }
      }
  }
}


extension Reactive where Base: DownloadRequest {
    
  public func response() -> Observable<DefaultDownloadResponse> {
    return Observable.create { observer in
      let request = self.base.response { response in
        if let error = response.error {
          observer.onError(error)
        } else {
          observer.onNext(response)
          observer.onCompleted()
        }
      }
      return Disposables.create(with: request.cancel)
    }
