const std::map<std::string, std::string>& endpoint_params) {

  if (in_flight_request_ != nullptr) {

  const auto encoded_client_id = Envoy::Http::Utility::PercentEncoding::encode(client_id, ":/=&?");

  const auto encoded_secret = Envoy::Http::Utility::PercentEncoding::encode(secret, ":/=&?");

  Envoy::Http::RequestMessagePtr request = createPostRequest();

  std::string body;

  if (scopes.empty()) {

    body = fmt::format(GetAccessTokenBodyFormatString, encoded_client_id, encoded_secret);

  } else {

    const auto encoded_scopes = Envoy::Http::Utility::PercentEncoding::encode(scopes, ":/=&?");

    body = fmt::format(GetAccessTokenBodyFormatStringWithScopes, encoded_client_id, encoded_secret,

                       encoded_scopes);

  }

  for (const auto& [param_name, param_value] : endpoint_params) {

    const auto encoded_name = Envoy::Http::Utility::PercentEncoding::encode(param_name, ":/=&?");

    const auto encoded_value = Envoy::Http::Utility::PercentEncoding::encode(param_value, ":/=&?");

    body += fmt::format("&{}={}", encoded_name, encoded_value);

  }

  request->body().add(body);

  request->headers().setContentLength(body.length());

  return dispatchRequest(std::move(request));

}

OAuth2ClientImpl::dispatchRequest(Envoy::Http::RequestMessagePtr&& msg) {

  const auto thread_local_cluster = cm_.getThreadLocalCluster(uri_.cluster());

  if (thread_local_cluster != nullptr) {

    in_flight_request_ = thread_local_cluster->httpAsyncClient().send(

        std::move(msg), *this,

        Envoy::Http::AsyncClient::RequestOptions().setTimeout(

            std::chrono::milliseconds(PROTOBUF_GET_MS_REQUIRED(uri_, timeout))));

  } else {

    return GetTokenResult::NotDispatchedClusterNotFound;

  }

  return GetTokenResult::DispatchedRequest;

}

                                 Envoy::Http::ResponseMessagePtr&& message) {

  in_flight_request_ = nullptr;

  const auto response_code = message->headers().Status()->value().getStringView();

  if (response_code != "200") {

    ENVOY_LOG(error, "Oauth response code: {}", response_code);

    ENVOY_LOG(error, "Oauth response body: {}", message->bodyAsString());

    parent_->onGetAccessTokenFailure(FilterCallbacks::FailureReason::BadResponseCode);

    return;

  }

  const std::string response_body = message->bodyAsString();

  envoy::extensions::http::injected_credentials::oauth2::OAuthResponse response;

  TRY_NEEDS_AUDIT {

    MessageUtil::loadFromJson(response_body, response, ProtobufMessage::getNullValidationVisitor());

  }

  END_TRY catch (EnvoyException& e) {

    ENVOY_LOG(error, "Error parsing response body, received exception: {}", e.what());

    ENVOY_LOG(error, "Response body: {}", response_body);

    parent_->onGetAccessTokenFailure(FilterCallbacks::FailureReason::BadToken);

    return;

  }

  if (!response.has_access_token() || !response.has_expires_in()) {

    ENVOY_LOG(error, "No access token or expiration after asyncGetAccessToken");

    parent_->onGetAccessTokenFailure(FilterCallbacks::FailureReason::BadToken);

    return;

  }

  const std::string access_token{PROTOBUF_GET_WRAPPED_REQUIRED(response, access_token)};

  const std::chrono::seconds expires_in{PROTOBUF_GET_WRAPPED_REQUIRED(response, expires_in)};

  parent_->onGetAccessTokenSuccess(access_token, expires_in);

}

                                 Envoy::Http::AsyncClient::FailureReason) {

  ENVOY_LOG(error, "OAuth request failed: stream reset");

  in_flight_request_ = nullptr;

  parent_->onGetAccessTokenFailure(FilterCallbacks::FailureReason::StreamReset);

}