Add ActivePlugin point for Chat-tab contributions (#8948)

Task/Issue URL:
https://app.asana.com/1/137249556945/project/1214157224317277/task/1215897994835019
Tech Design URL (if applicable):
https://app.asana.com/1/137249556945/task/1215906519502283

### Description

Introduces `NativeInputChatTabItemPlugin`, an `ActivePluginPoint` that
lets modules outside `duckchat-impl` contribute their own item(s) to the
native-input Chat-tab suggestions list (the list shown under the
**Chat** tab when the input is focused in *Search & Duck.ai* mode),
gated by remote config and without depending on `duckchat-impl`.

The full design lives in the [Tech
Design](https://app.asana.com/1/137249556945/task/1215906519502283).
Highlights:

- **API (`duckchat-api`):** `NativeInputChatTabItemPlugin` is a factory
for a per-binding `NativeInputChatTabItem`, which owns a
`RecyclerView.Adapter` slotted into the existing Chat-tab
`ConcatAdapter`. A plugin declares via `supportsQuery` whether it
participates in filtering: `false` items are zero-state (shown only
while the query is empty, hidden once the user types); `true` items stay
and receive `onQueryChanged`. The interface lives in `duckchat-api` so
it travels with native input when it moves to its own module.
- **Plugin point (`duckchat-impl`):**
`pluginPointNativeInputChatTabItemPlugin` (default enabled); each
contributed plugin is additionally gated by its own
`@ContributesActivePlugin` flag. Ordering comes from
`@ContributesActivePlugin(priority = …)`.
- **Host (`duckchat-impl`):** `NativeInputChatSuggestionsBinder` loads
the enabled plugins and inserts each item's adapter at the **top** of
the `ConcatAdapter` in plugin-point order, above the built-in sections
(which are left untouched). `submit()` forwards the query only to
query-aware items and folds visible plugin content into the overlay's
`hasContent`. Loading is decoupled from `submit`, so the latest `submit`
is replayed once plugins finish loading. `NativeInputModeWidget` owns a
per-binding `CoroutineScope` handed to each item, cancelled at teardown.

This is the first step toward later migrating the existing sections
(chat history, "View all Chats", URL suggestions, "Search for …") onto
the same plugin point — see the Tech Design.

**No user-facing change:** this PR adds the mechanism only; there are no
contributors yet (an internal-only example card was used to validate the
contract during development and has been removed).

### Steps to test this PR

_Plugin mechanism (no user-visible change)_
- [ ] `./gradlew :duckchat-impl:testDebugUnitTest --tests
"com.duckduckgo.duckchat.impl.ui.nativeinput.views.NativeInputChatSuggestionsBinderTest"`
passes — covers top insertion in priority order, query forwarding only
to `supportsQuery == true` items, non-query items hidden while typing
and restored on clear, `hasContent` aggregation, and the load-vs-submit
race (replay).
- [ ] App builds and the Chat tab behaves exactly as before, since no
module contributes a plugin yet.

### UI changes
| Before  | After |
| ------ | ----- |
| _No UI changes — mechanism only, no contributors yet_ | |

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Medium Risk**
> Touches native input overlay visibility and keystroke-driven state;
behavior is heavily unit-tested but affects a core Duck.ai input UX
path.
> 
> **Overview**
> Adds an **ActivePlugin** extension point so other modules can
contribute rows to the native-input **Chat** tab suggestions list
without depending on `duckchat-impl`. The API exposes
`NativeInputChatTabItemPlugin` / `NativeInputChatTabItem`, plus
`SingleViewChatTabItem` for single-card contributions, and extends
**`DuckChatInputModeState`** with a **`chatQuery`** `StateFlow` (kept in
sync from `InputModeWidget` via **`setChatQuery`**).
> 
> The host **`NativeInputChatSuggestionsBinder`** loads enabled plugins
into the top of the existing **`ConcatAdapter`**, observes adapter
changes to recompute overlay **`hasContent`** (using live
**`chatQuery`** so zero-state cards can hide without flickering the
overlay closed while the user types), and **`NativeInputModeWidget`**
owns a scoped coroutine job for plugin loading/teardown. An
internal-only **`ExampleMessageCardPlugin`** demonstrates the pattern;
unit tests cover ordering, overlay aggregation, load-after-submit,
dismiss, and clear races.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
9ad5e42. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: malmstein

duckchat/duckchat-api/build.gradle

@@ -34,6 +34,7 @@ dependencies {
 
     implementation KotlinX.coroutines.core
     implementation AndroidX.appCompat
+    implementation AndroidX.recyclerView
 
     coreLibraryDesugaring Android.tools.desugarJdkLibs
 

duckchat/duckchat-api/src/main/java/com/duckduckgo/duckchat/api/DuckChatInputModeState.kt

@@ -35,6 +35,16 @@ interface DuckChatInputModeState {
      * no Duck.ai input widget is attached.
      */
     val displayedMode: StateFlow<InputMode>
+
+    /**
+     * The current Chat-tab query — the text typed while the Chat tab is the input target.
+     *
+     * High-frequency (updates per keystroke), kept as its own flow so it doesn't churn
+     * [displayedMode] consumers. Holds [""] when the Chat tab isn't the target (Search tab selected
+     * or no widget attached), mirroring how [displayedMode] resets to [InputMode.SEARCH]. A sibling
+     * `searchQuery` can follow the same pattern for the Search tab.
+     */
+    val chatQuery: StateFlow<String>
 }
 
 /**

duckchat/duckchat-api/src/main/java/com/duckduckgo/duckchat/api/inputscreen/NativeInputChatTabItemPlugin.kt

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026 DuckDuckGo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 com.duckduckgo.duckchat.api.inputscreen
+
+import android.content.Context
+import androidx.recyclerview.widget.RecyclerView
+import com.duckduckgo.common.utils.plugins.ActivePlugin
+import kotlinx.coroutines.CoroutineScope
+
+/**
+ * Lets a module contribute its own item(s) to the native-input Chat-tab suggestions list without
+ * depending on `duckchat-impl`. The host slots each contribution's [RecyclerView.Adapter]s into the
+ * Chat-tab's `ConcatAdapter`.
+ *
+ * The plugin is a singleton in the DI graph (it is multibound); it acts as a factory because the
+ * contributed adapters are stateful and bound to a single Chat-tab presentation. Implement with
+ * `@ContributesActivePlugin`, set `parentFeatureName = "pluginPointNativeInputChatTabItemPlugin"`, and
+ * set `priority` to one of the [companion] constants to order against other contributions.
+ *
+ * For the common case of a single static view (e.g. a card), extend [SingleViewChatTabItem] instead
+ * of implementing [NativeInputChatTabItem] directly.
+ */
+interface NativeInputChatTabItemPlugin : ActivePlugin {
+
+    /**
+     * Create a fresh item bound to one Chat-tab presentation.
+     *
+     * @param context a view context suitable for inflating the item's views.
+     * @param scope cancelled by the host when the Chat tab is torn down. Use it to collect data into
+     * the returned adapters; do not retain it beyond the returned [NativeInputChatTabItem].
+     */
+    fun create(context: Context, scope: CoroutineScope): NativeInputChatTabItem
+
+    companion object {
+        // Order of contributions, top to bottom. Lower value comes first (higher in the list); gaps
+        // leave room to insert new contributions; equal values are allowed and tie-break by class name.
+        // Mirrors NewTabPageSectionPlugin. The built-in sections will claim their own constants here as
+        // they migrate onto this plugin point; until then they render below all contributions.
+        const val PRIORITY_PROMO = 100
+        const val PRIORITY_CHAT_HISTORY = 200
+        const val PRIORITY_URL_SUGGESTIONS = 300
+        const val PRIORITY_SEARCH_FOR = 400
+    }
+}
+
+/**
+ * A single contribution to the Chat-tab list. Purely a rendering surface: it owns its adapter(s) and
+ * view holders, and the host only positions them.
+ *
+ * Input state the item needs to decide its rows — the current query, the displayed mode — is read from
+ * the shared state in this module (e.g. [com.duckduckgo.duckchat.api.DuckChatInputModeState.chatQuery]
+ * and `displayedMode`), not pushed in here. An item observes that state (combining it with its own
+ * async data) and updates its adapter(s); an item with no rows contributes no content and does not keep
+ * the suggestions overlay open. For the common single-view card see [SingleViewChatTabItem].
+ */
+interface NativeInputChatTabItem {
+
+    /**
+     * The adapters slotted into the host's `ConcatAdapter`, in order. Most items contribute a single
+     * adapter; returning several lets one item own multiple sections without nesting `ConcatAdapter`s.
+     * The plugin fully owns each adapter's item count and view holders.
+     */
+    val adapters: List<RecyclerView.Adapter<*>>
+}

duckchat/duckchat-api/src/main/java/com/duckduckgo/duckchat/api/inputscreen/SingleViewChatTabItem.kt

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2026 DuckDuckGo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 com.duckduckgo.duckchat.api.inputscreen
+
+import android.view.View
+import android.view.ViewGroup
+import androidx.recyclerview.widget.RecyclerView
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.launch
+
+/**
+ * Convenience [NativeInputChatTabItem] for the common case of a single, static view (e.g. a card).
+ *
+ * Provide the view in [onCreateView] and a [visible] flow that drives whether the row is shown. The
+ * flow is the single knob: compose it from whatever state the item cares about — e.g.
+ * `chatQuery.map { it.isEmpty() }` for a zero-state card that hides while the user types, the item's
+ * own data for a state-driven card, both combined, or `flowOf(true)` to always show. [hide] is a
+ * sticky override (e.g. on dismiss) that wins over [visible] for the rest of the presentation.
+ *
+ * Items that need multiple rows, view recycling across many items, or several sections should
+ * implement [NativeInputChatTabItem] directly.
+ */
+abstract class SingleViewChatTabItem(
+    visible: Flow<Boolean>,
+    scope: CoroutineScope,
+) : NativeInputChatTabItem {
+
+    /** Create the view shown as the single row. Called once; [parent] supplies the context. */
+    abstract fun onCreateView(parent: ViewGroup): View
+
+    private val singleViewAdapter = SingleViewAdapter()
+    private val dismissed = MutableStateFlow(false)
+
+    final override val adapters: List<RecyclerView.Adapter<*>> = listOf(singleViewAdapter)
+
+    init {
+        scope.launch {
+            combine(visible, dismissed) { show, gone -> show && !gone }
+                .collect { singleViewAdapter.setVisible(it) }
+        }
+    }
+
+    /** Permanently hide this item for the current presentation (e.g. on dismiss); wins over [visible]. */
+    protected fun hide() {
+        dismissed.value = true
+    }
+
+    private inner class SingleViewAdapter : RecyclerView.Adapter<SingleViewHolder>() {
+        private var visible = false
+
+        fun setVisible(value: Boolean) {
+            if (value == visible) return
+            visible = value
+            if (value) notifyItemInserted(0) else notifyItemRemoved(0)
+        }
+
+        override fun getItemCount(): Int = if (visible) 1 else 0
+
+        override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): SingleViewHolder {
+            val view = onCreateView(parent).apply {
+                if (layoutParams == null) {
+                    layoutParams = RecyclerView.LayoutParams(
+                        ViewGroup.LayoutParams.MATCH_PARENT,
+                        ViewGroup.LayoutParams.WRAP_CONTENT,
+                    )
+                }
+            }
+            return SingleViewHolder(view)
+        }
+
+        override fun onBindViewHolder(holder: SingleViewHolder, position: Int) = Unit
+    }
+
+    private class SingleViewHolder(view: View) : RecyclerView.ViewHolder(view)
+}

duckchat/duckchat-api/src/test/kotlin/com/duckduckgo/duckchat/api/inputscreen/SingleViewChatTabItemTest.kt

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2026 DuckDuckGo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 com.duckduckgo.duckchat.api.inputscreen
+
+import android.view.View
+import android.view.ViewGroup
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class SingleViewChatTabItemTest {
+
+    private class TestItem(visible: Flow<Boolean>, scope: CoroutineScope) : SingleViewChatTabItem(visible, scope) {
+        override fun onCreateView(parent: ViewGroup): View = View(parent.context)
+        fun dismiss() = hide()
+    }
+
+    private fun NativeInputChatTabItem.rows(): Int = adapters.single().itemCount
+
+    @Test
+    fun whenVisibleTrueThenRowShown() = runTest {
+        val item = TestItem(MutableStateFlow(true), CoroutineScope(UnconfinedTestDispatcher(testScheduler)))
+
+        assertEquals(1, item.rows())
+    }
+
+    @Test
+    fun whenVisibleFalseThenNoRow() = runTest {
+        val item = TestItem(MutableStateFlow(false), CoroutineScope(UnconfinedTestDispatcher(testScheduler)))
+
+        assertEquals(0, item.rows())
+    }
+
+    @Test
+    fun whenVisibleTogglesThenRowToggles() = runTest {
+        val visible = MutableStateFlow(true)
+        val item = TestItem(visible, CoroutineScope(UnconfinedTestDispatcher(testScheduler)))
+        assertEquals(1, item.rows())
+
+        visible.value = false
+        assertEquals(0, item.rows())
+
+        visible.value = true
+        assertEquals(1, item.rows())
+    }
+
+    @Test
+    fun whenDismissedThenStaysHiddenEvenWhenVisibleTrue() = runTest {
+        val visible = MutableStateFlow(true)
+        val item = TestItem(visible, CoroutineScope(UnconfinedTestDispatcher(testScheduler)))
+        assertEquals(1, item.rows())
+
+        item.dismiss()
+        assertEquals(0, item.rows())
+
+        // A later visible=true must not bring it back.
+        visible.value = false
+        visible.value = true
+        assertEquals(0, item.rows())
+    }
+}

duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/RealDuckChat.kt

@@ -126,6 +126,13 @@ interface DuckChatInternal : DuckChat {
      */
     fun setSelectedMode(mode: InputMode)
 
+    /**
+     * Updates the live Chat-tab query. Called by [InputModeWidget] as the user types on the Chat tab,
+     * and reset to [""] when the Chat tab isn't the target, to keep [DuckChatInputModeState.chatQuery]
+     * in sync with the actual widget state.
+     */
+    fun setChatQuery(query: String)
+
     /**
      * Observes whether DuckChat is user enabled or disabled.
      */
@@ -397,6 +404,7 @@ class RealDuckChat @Inject constructor(
     private val _showContextualMode = MutableStateFlow(false)
     private val _allowDuckAiAsDigitalAssistant = MutableStateFlow(false)
     private val _displayedMode = MutableStateFlow(InputMode.SEARCH)
+    private val _chatQuery = MutableStateFlow("")
 
     private val jsonAdapter: JsonAdapter<DuckChatSettingJson> by lazy {
         moshi.adapter(DuckChatSettingJson::class.java)
@@ -827,6 +835,12 @@ class RealDuckChat @Inject constructor(
         _displayedMode.value = mode
     }
 
+    override val chatQuery: StateFlow<String> = _chatQuery.asStateFlow()
+
+    override fun setChatQuery(query: String) {
+        _chatQuery.value = query
+    }
+
     private suspend fun hasActiveSession(): Boolean {
         val now = System.currentTimeMillis()
         val lastSession = duckChatFeatureRepository.lastSessionTimestamp()

duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/inputscreen/ui/suggestions/NativeInputChatTabItemPluginPoint.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2026 DuckDuckGo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 com.duckduckgo.duckchat.impl.inputscreen.ui.suggestions
+
+import com.duckduckgo.anvil.annotations.ContributesActivePluginPoint
+import com.duckduckgo.di.scopes.AppScope
+import com.duckduckgo.duckchat.api.inputscreen.NativeInputChatTabItemPlugin
+
+/**
+ * Active plugin point for [NativeInputChatTabItemPlugin]. The generated point is gated by the
+ * "pluginPointNativeInputChatTabItemPlugin" remote feature flag (default enabled); each contributed
+ * plugin is additionally gated by its own `@ContributesActivePlugin` flag.
+ */
+@ContributesActivePluginPoint(
+    scope = AppScope::class,
+    boundType = NativeInputChatTabItemPlugin::class,
+    featureName = "pluginPointNativeInputChatTabItemPlugin",
+)
+private interface NativeInputChatTabItemPluginPointTrigger