     
     if workers.isEmpty {
       // Only show an error if we found nothing
-      request.context?.perform {
+      request.perform { _ in
         if request.trips.isEmpty, let error = self.lastWorkerError {
           completion(.failure(error))
         } else {

    }
    
    TKRegionManager.shared.requireRegions { [weak self] result in
      guard let self = self else { return }

      if case .failure(let error) = result {
        return self.handleError(error, callbackQueue: callbackQueue, completion: completion)
      }
      
      // we are guaranteed to have regions
      guard let region = TKRegionManager.shared.localRegions(start: request.from.coordinate, end: request.to.coordinate).first else {
        return self.handleError(
          NSError(code: 1001, // matches server
                  message: Loc.RoutingBetweenTheseLocationsIsNotYetSupported),
          callbackQueue: callbackQueue,
          completion: completion)
      }
      
      let paras = Self.requestParameters(
        for: request,
        modeIdentifiers: self.modeIdentifiers,
        additional: additional,
        bestOnly: bestOnly
      )
      
      let server = self.server ?? .shared
      server.hit(TKAPI.RoutingResponse.self,
                 path: "routing.json",
                 parameters: paras,
                 region: region,
                 callbackOnMain: false
      ) { [weak self] _, _, result in
        guard let self = self else { return }
        switch result {
        case .success(let response):
          if let context = request.context {
            context.perform {
              let tripRequest = request.toTripRequest()
              self.parse(response, for: tripRequest, visibility: visibility, callbackQueue: callbackQueue, completion: completion)
            }
          } else {
            let tripRequest = request.toTripRequest()
            self.parse(response, for: tripRequest, visibility: visibility, callbackQueue: callbackQueue, completion: completion)
          }
          
        case .failure(let error):
          self.handleError(error, callbackQueue: callbackQueue, completion: completion)
        }
      }
    }

          case .success:
            // Classifiers will likely heavily read from the trips, so
            // we need to switch
            request.perform { _ in
              if modes == nil {
                // We get hidden modes here in the completion block
                // since they might have changed while waiting for results
