You can use org.json which is shipped with Android:

JSONObject(map).toString()

No additional library is needed:

val jsonObj = JSONObject(jsonString)
val map = jsonObj.toMap()

where toMap is:

fun JSONObject.toMap(): Map<String, *> = keys().asSequence().associateWith {
    when (val value = this[it])
    {
        is JSONArray ->
        {
            val map = (0 until value.length()).associate { Pair(it.toString(), value[it]) }
            JSONObject(map).toMap().values.toList()
        }
        is JSONObject -> value.toMap()
        JSONObject.NULL -> null
        else            -> value
    }
}

The answer provided by Bitwise DEVS may work, but the explanation is incorrect.

It is not necessary to convert the map into an immutable map - it can even be seen in the screenshot of the question: expected (Mutable)Map means that it can be mutable or immutable.

The real problem here is that the called constructor of JSONObject is defined for Map<Any?, Any?> but the given parameter is of type Map<String!, String!>. We know that String is a subtype of Any?, so why is that a problem?

It is a problem because Map is invariant in the key parameter which means that a Map<A, V> is not subtype of Map<B, V> even if A is subtype of B (and also not if it is the other way around).

The call of toMap does not work because it makes the map immutable, but because it is defined as

fun <K, V> Map<out K, V>.toMap(): Map<K, V>

In the receiver type of toMap the key parameter is annotated with the out modifier, meaning that K is covariant here. This means that a Map<Any, V> in this position can safely be considered as a supertype of Map<String, V>. Additionally, Map is always covariant in its value type, meaning that Map<Any, Any> in this position can safely be considered as a supertype of Map<String, String>.

You could as well just cast remoteMessage.data as Map<Any?, Any?> or use toMutableMap, it would be all the same. It has definitely nothing to do with mutability of the map.

Kotlin documentation on variance: https://kotlinlang.org/docs/generics.html#declaration-site-variance

Kotlin documentation of Map: https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-map/

Definition of toMap: https://github.com/JetBrains/kotlin/blob/ea836fd46a1fef07d77c96f9d7e8d7807f793453/libraries/stdlib/src/kotlin/collections/Maps.kt#L600

Alongside

implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.1")

you also need explicit dependencies to

implementation("io.ktor:ktor-client-content-negotiation:2.3.1")
implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.1")

and an HTTP client configuration to let Ktor know how to deserialize the data, for example

import io.ktor.client.*
import io.ktor.client.engine.java.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.serialization.json.Json
import java.net.http.HttpClient.Version.HTTP_2

val httpClient = HttpClient(Java) {
    engine {
        threadsCount = 4
        pipelining = true
        protocolVersion = HTTP_2
    }

    install(ContentNegotiation) {
        json(Json {
            prettyPrint = true
            ignoreUnknownKeys = true
        })
    }
}

This way the Ktor Client will be able to actually use the kotlinx.serialization to deserialize the response into your desired entity Oauth.

Alternatively, if you really want only a simple Map object instead of complex (de)serialization then I'm pretty sure you'd need to use either Gson, Jackson, Moshi or something as simple as Klaxon to deserialize the response body string.

For example, using Klaxon:

val parser: Parser = Parser.default()
val body: String = httpClient.get("https://example.com/api/tokens").bodyAsText()
val json: JsonObject = parser.parse(body) as JsonObject

where JsonObject behaves almost like a Map: https://github.com/cbeust/klaxon#low-level-api