@kindly-ai/react-native 1.0.13 → 1.0.15

package/README.md

@@ -37,6 +37,33 @@ KindlySDK.start({
   },
 });
 
+// Identity providers that issue more than a single JWT - a companion access
+// token, an issuer, or an opaque token whose expiry only you know - use
+// authCredentialsCallback instead. It wins when both are given.
+KindlySDK.start({
+  botKey: 'YOUR_BOT_KEY',
+  market: 'general',
+  authCredentialsCallback: async (chatId) => {
+    const tokens = await yourAuthBackend.getTokens({ chatId });
+    return {
+      idToken: tokens.idToken,             // optional
+      accessToken: tokens.accessToken,     // optional
+      issuer: 'https://idp.example.com/',  // optional
+      expiresAt: tokens.expiresAtUnixSeconds, // optional, Unix seconds
+    };
+  },
+});
+
+// Only an access token? Return only that. It becomes the bearer.
+KindlySDK.start({
+  botKey: 'YOUR_BOT_KEY',
+  market: 'general',
+  authCredentialsCallback: async () => ({
+    accessToken: await yourAuthBackend.getAccessToken(),
+    issuer: 'https://idp.example.com/',
+  }),
+});
+
 // 2. Open the chat UI when the user wants it
 <Button title="Open chat" onPress={() => KindlySDK.launchChat()} />
 
@@ -59,7 +86,7 @@ KindlySDK.setDelegate({
 
 | Method | Purpose |
 |---|---|
-| `start({botKey, market, languageCode?, authTokenCallback?})` | Initialize the SDK. Must be called before any other method. `market` is **required** (Markets feature); the SDK loads that market's settings with no fallback. |
+| `start({botKey, market, languageCode?, authTokenCallback?, authCredentialsCallback?})` | Initialize the SDK. Must be called before any other method. `market` is **required** (Markets feature); the SDK loads that market's settings with no fallback. Use `authCredentialsCallback` for identity providers that issue more than a single JWT. |
 | `displayChat({languageCode?, triggerDialogueId?})` | Show the chat UI. |
 | `launchChat({triggerDialogueId?})` | Connect (if needed) and show chat. Recommended on Android. |
 | `closeChat()` | Dismiss the UI without ending the session. |
@@ -67,6 +94,32 @@ KindlySDK.setDelegate({
 | `kill()` | Tear the SDK down completely; call `start()` again before reuse. |
 | `setLanguage(code)` | Update the language for the current session. |
 
+### Authentication
+
+| Method | Purpose |
+|---|---|
+| `authenticate()` | Re-authenticate the live chat with fresh credentials. For a sign-in mid-session; expiry is handled by the SDK on its own. |
+| `deauthenticate()` | Sign out of the chat without ending it. History is kept, the chat continues anonymously. |
+
+Every field of `KindlyAuthCredentials` is optional, but set at least one of `idToken` /
+`accessToken`. Whichever you supply becomes the `Authorization: Bearer`, id token first. A provider
+that issues only an access token is a normal, supported case, not a workaround. Credentials with
+neither token cannot authenticate and the chat stays anonymous.
+
+Send `accessToken` alongside `idToken` only when the two really are a pair from the same provider.
+The backend verifies the companion against the id token's `at_hash` and rejects a mismatch, so
+passing the same value in both fields fails an auth that would otherwise have succeeded. The SDK
+drops a companion that duplicates the id token rather than sending it.
+
+The SDK refreshes credentials 30 seconds before they expire, using whichever is earliest of the
+backend's reported expiry, your `expiresAt`, and the `exp` claim of the bearer. If none is known the
+credentials are treated as non-expiring - a trap for opaque tokens, so set `expiresAt` there. A
+token the SDK cannot parse means the expiry is unknown, never that the token is expired.
+
+`deauthenticate()` is safe to call when the chat is already anonymous. The local credentials are
+cleared even if the backend call fails, so a sign-out is never left half done, but the promise still
+rejects so you know the backend did not hear about it.
+
 ### Messaging
 
 | Method | Purpose |

package/android/src/main/java/com/kindlyai/reactnative/KindlyReactNativeModule.kt

@@ -22,6 +22,8 @@ import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withTimeoutOrNull
 import no.kindly.chatsdk.chat.AuthTokenCallback
 import no.kindly.chatsdk.chat.ChatKindlySDK
+import no.kindly.chatsdk.chat.KindlyAuthCredentials
+import no.kindly.chatsdk.chat.KindlyAuthCredentialsProvider
 import no.kindly.chatsdk.chat.common.CallbackHandover
 import no.kindly.chatsdk.chat.common.KindlySDKInteraction
 import no.kindly.chatsdk.chat.domain.MessageChat
@@ -59,6 +61,7 @@ class KindlyReactNativeModule(reactContext: ReactApplicationContext) :
 
   // Pending request maps for the sync round-trips.
   private val authPending = ConcurrentHashMap<String, CompletableDeferred<String?>>()
+  private val credentialsPending = ConcurrentHashMap<String, CompletableDeferred<ReadableMap?>>()
   private val shouldHandlePending = ConcurrentHashMap<String, CompletableDeferred<Boolean>>()
 
   // Delegate bridge — set on ChatKindlySDK.`interface` when at least one
@@ -86,13 +89,24 @@ class KindlyReactNativeModule(reactContext: ReactApplicationContext) :
     // Best-effort — clear any pending deferreds so the JS side doesn't hang.
     authPending.values.forEach { it.complete(null) }
     authPending.clear()
+    // A null credentials map yields a credential with no token, which the
+    // provider below rejects, so the chat falls back to anonymous instead of
+    // sitting on a deferred nobody will ever complete.
+    credentialsPending.values.forEach { it.complete(null) }
+    credentialsPending.clear()
     shouldHandlePending.values.forEach { it.complete(true) }
     shouldHandlePending.clear()
   }
 
   // MARK: - Lifecycle
 
-  override fun start(botKey: String, languageCode: String?, market: String, hasAuthCallback: Boolean) {
+  override fun start(
+    botKey: String,
+    languageCode: String?,
+    market: String,
+    hasAuthCallback: Boolean,
+    hasAuthCredentialsCallback: Boolean,
+  ) {
     val app = context.applicationContext as? Application
     if (app == null) return
 
@@ -120,15 +134,69 @@ class KindlyReactNativeModule(reactContext: ReactApplicationContext) :
       null
     }
 
+    // The credentials provider wins when both are wired, matching the native SDKs.
+    val credentialsProvider: KindlyAuthCredentialsProvider? = if (hasAuthCredentialsCallback) {
+      KindlyAuthCredentialsProvider { request ->
+        val requestId = UUID.randomUUID().toString()
+        val pending = CompletableDeferred<ReadableMap?>()
+        credentialsPending[requestId] = pending
+
+        emitEvent("KindlyGetAuthCredentials", Arguments.createMap().apply {
+          putString("requestId", requestId)
+          putString("chatId", request.chatId)
+        })
+
+        val map = pending.await()
+        fun str(key: String): String? =
+          map?.takeIf { it.hasKey(key) && !it.isNull(key) }?.getString(key)
+
+        // Both tokens are optional and either one alone is a valid credential:
+        // the SDK picks the bearer itself via `bearerToken`. The only thing that
+        // disqualifies a credential is carrying neither, which is what
+        // `hasToken` answers. Never gate on `idToken`.
+        val credentials = KindlyAuthCredentials(
+          idToken = str("idToken"),
+          accessToken = str("accessToken"),
+          issuer = str("issuer"),
+          // JS numbers cross the bridge as Double.
+          expiresAt = map?.takeIf { it.hasKey("expiresAt") && !it.isNull("expiresAt") }
+            ?.getDouble("expiresAt")?.toLong(),
+        )
+        if (!credentials.hasToken) {
+          throw IllegalStateException("Auth credentials not provided")
+        }
+        credentials
+      }
+    } else {
+      null
+    }
+
     ChatKindlySDK.start(
       application = app,
       botKey = botKey,
       languageCode = languageCode ?: "en",
       market = market,
       authTokenCallback = authCallback,
+      authCredentialsProvider = credentialsProvider,
     )
   }
 
+  override fun authenticate(promise: Promise) {
+    scope.launch {
+      runCatching { ChatKindlySDK.authenticate().await() }
+        .onSuccess { promise.resolve(null) }
+        .onFailure { promise.reject("AUTH_FAILED", it.message, it) }
+    }
+  }
+
+  override fun deauthenticate(promise: Promise) {
+    scope.launch {
+      runCatching { ChatKindlySDK.deauthenticate().await() }
+        .onSuccess { promise.resolve(null) }
+        .onFailure { promise.reject("DEAUTH_FAILED", it.message, it) }
+    }
+  }
+
   override fun displayChat(languageCode: String?, triggerDialogueId: String?) {
     val act = getCurrentActivity() ?: return
     ChatKindlySDK.displayChat(act)
@@ -309,6 +377,10 @@ class KindlyReactNativeModule(reactContext: ReactApplicationContext) :
     authPending.remove(requestId)?.complete(token)
   }
 
+  override fun respondToAuthCredentials(requestId: String, credentials: ReadableMap?) {
+    credentialsPending.remove(requestId)?.complete(credentials)
+  }
+
   override fun respondToShouldHandle(requestId: String, value: Boolean) {
     shouldHandlePending.remove(requestId)?.complete(value)
   }