Fix mention suggestion filter to use substring matching instead of fuzzy Levenshtein filtering. The previous implementation filtered by Levenshtein distance < threshold, causing short queries like @jc to match unrelated names (e.g. "Aleksandar") because the distance was below the cutoff. Now filters by substring containment and sorts by Levenshtein distance, aligning with the Swift SDK.

Author: andremion

stream-chat-android-ui-common/src/main/kotlin/io/getstream/chat/android/ui/common/feature/messages/composer/query/filter/DefaultQueryFilter.kt

@@ -29,20 +29,19 @@ import kotlin.math.min
 /**
  * Default implementation of [QueryFilter].
  *
- * This implementation of [QueryFilter] ignores upper case, diacritics
- * It uses levenshtein approximation so typos are included in the search.
+ * Keeps only items whose normalized target contains the normalized query as a substring, then
+ * sorts results by Levenshtein distance so the closest matches appear first. Normalization
+ * applies lowercasing, diacritics removal, and optional transliteration.
  *
- * It is possible to choose a transliteration by providing a [transliterator].
- *
- * @param transliterator The transliterator to use for transliterating the query string.
- * @param target The function to extract the target string from the item.
+ * @param transliterator The transliterator to use for normalizing strings.
+ * @param target The function to extract the searchable string from an item.
  */
 public class DefaultQueryFilter<T>(
     private val transliterator: StreamTransliterator = DefaultStreamTransliterator(),
     private val target: (T) -> String,
 ) : QueryFilter<T> {
 
-    private val logger by taggedLogger("Chat:InputQueryFilter")
+    private val logger by taggedLogger("Chat:QueryFilter")
 
     private val queryFormatter: QueryFormatter = Combine(
         Lowercase(),
@@ -53,73 +52,18 @@ public class DefaultQueryFilter<T>(
     override fun filter(items: List<T>, query: String): List<T> {
         logger.d { "[filter] query: \"$query\", items.size: ${items.size}" }
         val formattedQuery = queryFormatter.format(query)
-        return items.asSequence()
-            .map { it.measureDistance(formattedQuery) }
-            .filter { it.distance < MAX_DISTANCE }
-            .sorted()
-            .onEach { logger.v { "[filter] target: \"${target(it.item)}\", distance: ${it.distance}" } }
-            .map { it.item }
-            .toList()
-    }
-
-    private fun T.measureDistance(formattedQuery: String): MeasuredItem<T> {
-        val target = target(this)
-        if (target.isEmpty() || formattedQuery.length > target.length) {
-            logger.v { "[measureDistance] #skip; target: \"$target\", formattedQuery: \"$formattedQuery\"" }
-            return MeasuredItem(this, Int.MAX_VALUE)
-        }
-        val formattedTarget = queryFormatter.format(target)
-        val distance = when (formattedTarget.contains(formattedQuery, ignoreCase = true)) {
-            true -> 0
-            else -> {
-                val finalTarget = when (formattedTarget.length > formattedQuery.length) {
-                    true -> formattedTarget.substring(0, formattedQuery.length)
-                    else -> formattedTarget
-                }
-                levenshteinDistance(formattedQuery, finalTarget)
-            }
-        }
-        return MeasuredItem(this, distance)
-    }
-
-    private data class MeasuredItem<T>(val item: T, val distance: Int) : Comparable<MeasuredItem<T>> {
-        override fun compareTo(other: MeasuredItem<T>): Int {
-            return distance.compareTo(other.distance)
-        }
-    }
-
-    private fun minLevenshteinDistance(search: String, target: String): Int {
-        val totalDistance = levenshteinDistance(search, target)
-        val wordDistance = wordLevenshteinDistance(search, target)
-        return minOf(totalDistance, wordDistance)
-    }
-
-    private fun wordLevenshteinDistance(search: String, target: String): Int {
-        try {
-            if (search.isEmpty() || target.isEmpty()) {
-                return Int.MAX_VALUE
-            }
-            var distance = Int.MAX_VALUE
-            var sStartIndex = 0
-            var tStartIndex = 0
-            while (true) {
-                val sEndIndex = search.indexOf(startIndex = sStartIndex, char = SPACE)
-                val tEndIndex = target.indexOf(startIndex = tStartIndex, char = SPACE)
-                if (tEndIndex == -1) {
-                    break
+        if (formattedQuery.isEmpty()) return items
+        return items
+            .mapNotNull { item ->
+                val formattedTarget = queryFormatter.format(target(item))
+                if (formattedTarget.contains(formattedQuery)) {
+                    item to levenshteinDistance(formattedQuery, formattedTarget)
+                } else {
+                    null
                 }
-                val subSearch = if (sEndIndex == -1) search else search.substring(sStartIndex, sEndIndex)
-                val subTarget = target.substring(tStartIndex, tEndIndex)
-                val subDistance = levenshteinDistance(subSearch, subTarget)
-                distance = minOf(distance, subDistance)
-                sStartIndex = sEndIndex + 1
-                tStartIndex = tEndIndex + 1
             }
-            return distance
-        } catch (e: Throwable) {
-            logger.e(e) { "[wordLevenshteinDistance] failed: $e" }
-            return Int.MAX_VALUE
-        }
+            .sortedBy { (_, distance) -> distance }
+            .map { (item, _) -> item }
     }
 
     private fun levenshteinDistance(search: String, target: String): Int {
@@ -155,9 +99,4 @@ public class DefaultQueryFilter<T>(
 
         return cost[searchLength - 1]
     }
-
-    private companion object {
-        private const val MAX_DISTANCE = 3
-        private const val SPACE = ' '
-    }
 }

stream-chat-android-ui-common/src/test/kotlin/io/getstream/chat/android/ui/common/feature/messages/composer/query/filter/DefaultQueryFilterTest.kt

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2014-2026 Stream.io Inc. All rights reserved.
+ *
+ * Licensed under the Stream License;
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://github.com/GetStream/stream-chat-android/blob/main/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.getstream.chat.android.ui.common.feature.messages.composer.query.filter
+
+import io.getstream.chat.android.ui.common.feature.messages.composer.transliteration.DefaultStreamTransliterator
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class DefaultQueryFilterTest {
+
+    private val filter = DefaultQueryFilter<String>(
+        transliterator = DefaultStreamTransliterator(),
+        target = { it },
+    )
+
+    @Test
+    fun `empty query returns all items`() {
+        val names = listOf("Alice", "Bob")
+
+        assertEquals(listOf("Alice", "Bob"), filter.filter(names, ""))
+    }
+
+    @Test
+    fun `no match returns empty list`() {
+        val names = listOf("Alice", "Bob")
+
+        assertEquals(emptyList<String>(), filter.filter(names, "xyz"))
+    }
+
+    @Test
+    fun `match is case insensitive`() {
+        val names = listOf("Aleksandar Apostolov", "Jc Minarro")
+
+        assertEquals(listOf("Jc Minarro"), filter.filter(names, "JC"))
+    }
+
+    @Test
+    fun `match ignores diacritics`() {
+        val names = listOf("José", "Bob")
+
+        assertEquals(listOf("José"), filter.filter(names, "jose"))
+    }
+
+    @Test
+    fun `short query only matches names containing that substring`() {
+        val names = listOf("Aleksandar Apostolov", "Jc Minarro")
+
+        assertEquals(listOf("Jc Minarro"), filter.filter(names, "jc"))
+    }
+
+    @Test
+    fun `query does not fuzzy match unrelated names`() {
+        val names = listOf("Aleksandar Apostolov", "Ara", "AA BB CC", "Abel")
+
+        assertEquals(listOf("Aleksandar Apostolov"), filter.filter(names, "ale"))
+    }
+
+    @Test
+    fun `query matches substring in any word`() {
+        val names = listOf("Alice Smith", "Bob Jones", "Charlie Smith")
+
+        assertEquals(listOf("Alice Smith", "Charlie Smith"), filter.filter(names, "smith"))
+    }
+
+    @Test
+    fun `results are sorted by levenshtein distance`() {
+        val names = listOf("Charlie Alice", "Alice", "Bob Alice Smith")
+
+        assertEquals(listOf("Alice", "Charlie Alice", "Bob Alice Smith"), filter.filter(names, "alice"))
+    }
+}