Migrate StartChat plugin to NativeInputStateProvider (#8570)

Task/Issue URL:
https://app.asana.com/1/137249556945/project/1174433894299346/task/1214802413219916?focus=true

Stacked on #8556 — base is `feature/david/native_input_tabid_non_null`
until that merges.

### Description

First plugin migration onto the per-tab push model. `StartChatViewModel`
drops `DuckChatInputModeState` and observes the tab's `NativeInputState`
via `NativeInputStateProvider`.

- `NativeInputState` gets a stored `toggleSelection: ToggleSelection`
field (defaults to today's context-derived value via
`NativeInputState.defaultToggleFor`). `toggleSelection` is distinct from
`inputContext`: the context says where the widget lives, the selection
says which tab the user tapped — they can diverge inside a browser
omnibar.
- `NativeInputHost` exposes `val tabId: String`. The widget implements
it from `activeTabId`; reads pre-configure throw, mirroring
`getInputState()`.
- Widget's `configureMainButtonsVisibility` calls
`viewModel.setToggleSelection(...)` on every `onTabSelected` /
`onTabReselected`, before the existing `updatePluginContainerVisibility`
call. `WidgetConfig` carries a nullable `toggleSelection` override;
`configure()` resets it (null = follow context default).
- `StartChatViewModel` injects `NativeInputStateProvider` and exposes
`bindTabId(tabId)`; the combined `isVisible` flow `flatMapLatest`s on
`stateForTab(tabId)` and gates on `toggleSelection == SEARCH`.
- `StartChatView` stashes the host's tabId before attach and forwards it
to the VM from `onAttachedToWindow`; the plugin's `createView` calls
`bindTabId(host.tabId)` alongside the existing `onIconClicked` wiring.

`DuckChatInputModeState` stays in place — still consumed by ambient UI
(NTP background logo). Removal happens once nothing reads it.
`updatePluginContainerVisibility` carries a TODO: it becomes redundant
once every plugin reads `toggleSelection` from
`NativeInputStateProvider` and decides its own visibility.

### Steps to test this PR

_StartChat icon visibility_
- [ ] Enable Duck.ai feature + user setting on; disable input-screen
setting (search omnibar mode). On a website, focus the omnibar —
StartChat icon visible.
- [ ] Same setup, tap the Duck.ai tab in the toggle — icon hides.
- [ ] Tap back to the Search tab — icon reappears.
- [ ] Disable Duck.ai user setting — icon hides regardless of tab.
- [ ] Enable input-screen setting (SEARCH_AND_DUCK_AI mode) — icon
hides.

_Toggle / tab switching across tabs_
- [ ] Open a website on tab A, tap the Duck.ai toggle. Switch to a fresh
tab B in the browser. The widget should reflect tab B's selection
independently from tab A.

### UI changes

No visual change to existing UI; refactor of how the StartChat icon's
visibility is wired.

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Medium Risk**
> Moderate risk: refactors how native-input state is derived and
propagated across tabs, which can affect toggle selection, plugin
visibility, and SEARCH_ONLY vs SEARCH_AND_DUCK_AI UI rendering during
tab switches.
> 
> **Overview**
> **Native input state is reworked to be active-tab driven.**
`NativeInputState` drops `tabId`, adds a stored `toggleSelection`
(defaulted via `defaultToggleFor`), and `NativeInputStateProvider` now
exposes a `state: Flow<NativeInputState>` that follows the selected
browser tab.
> 
> **State propagation and UI syncing are updated.**
`RealNativeInputStateStore` now derives `state` from
`TabRepository.flowSelectedTab` (with a lazy injection to avoid a Dagger
cycle), while `NativeInputModeWidgetViewModel` publishes widget-owned
fields via `publisher.update` and tracks per-tab `toggleSelection`,
resetting it on `configure()`. `NativeInputModeWidget` always observes
`viewModel.state` (avoiding placeholder `zero()` emissions), keeps
`TabLayout` selection synchronized to `toggleSelection`, and only writes
selection back to state when the toggle row is user-visible.
> 
> **Plugins are migrated off host state reads.**
`NativeInputHost.getInputState()` is removed; `ModelPickerView` and
`StartChatViewModel` now observe `NativeInputStateProvider.state` to
drive surface/visibility logic, with new tests covering active-tab
emissions and StartChat visibility gating.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
50d8c0d. 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: David Gonzalez <malmstein@Davids-MacBook-Pro.local>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 3 people

duckchat/duckchat-api/src/main/java/com/duckduckgo/duckchat/api/nativeinput/NativeInputState.kt

@@ -20,7 +20,7 @@ data class NativeInputState(
     val inputMode: InputMode,
     val inputContext: InputContext,
     val inputPosition: InputPosition = InputPosition.TOP,
-    val tabId: String,
+    val toggleSelection: ToggleSelection = defaultToggleFor(inputContext),
 ) {
     enum class InputMode {
         SEARCH_AND_DUCK_AI,
@@ -37,23 +37,21 @@ data class NativeInputState(
 
     val isBottom: Boolean get() = inputPosition == InputPosition.BOTTOM
 
-    val defaultToggleSelection: ToggleSelection
-        get() = when (inputContext) {
+    companion object {
+        fun defaultToggleFor(context: InputContext): ToggleSelection = when (context) {
             InputContext.DUCK_AI, InputContext.DUCK_AI_CONTEXTUAL -> ToggleSelection.DUCK_AI
             InputContext.BROWSER -> ToggleSelection.SEARCH
         }
 
-    companion object {
         /**
          * Placeholder state used by [NativeInputStateProvider] for a tab that has not yet been
          * published to. Observers should not rely on these values: the native input widget overwrites
          * them via [NativeInputStatePublisher.publish] as soon as it is configured for the tab.
          */
-        fun zero(tabId: String): NativeInputState = NativeInputState(
+        fun zero(): NativeInputState = NativeInputState(
             inputMode = InputMode.SEARCH_AND_DUCK_AI,
             inputContext = InputContext.BROWSER,
             inputPosition = InputPosition.TOP,
-            tabId = tabId,
         )
     }
 }

duckchat/duckchat-api/src/main/java/com/duckduckgo/duckchat/api/nativeinput/NativeInputStateProvider.kt

@@ -16,15 +16,22 @@
 
 package com.duckduckgo.duckchat.api.nativeinput
 
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.StateFlow
 
 /**
  * Read-only access to the per-tab native input state. Components that need to react to input state
- * changes (toggle visibility, model selection, etc.) observe the flow for their tab.
+ * changes (toggle visibility, model selection, etc.) observe [state], which follows the currently
+ * selected browser tab and re-emits both when the tab changes and when the active tab's state is
+ * republished.
+ *
+ * [stateForTab] is for callers that already know a specific tabId and need synchronous keyed access
+ * — primarily the native input widget itself; plugins should observe [state].
  *
  * The writer-side counterpart is [NativeInputStatePublisher], which is reserved for the native input
  * widget; plugins must not depend on it.
  */
 interface NativeInputStateProvider {
+    val state: Flow<NativeInputState>
     fun stateForTab(tabId: String): StateFlow<NativeInputState>
 }

duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/nativeinput/NativeInputPlugin.kt

@@ -21,7 +21,6 @@ import android.view.View
 import com.duckduckgo.anvil.annotations.ContributesActivePluginPoint
 import com.duckduckgo.common.utils.plugins.ActivePlugin
 import com.duckduckgo.di.scopes.AppScope
-import com.duckduckgo.duckchat.api.nativeinput.NativeInputState
 
 sealed class PromptContribution {
     data class ModelSelection(val modelId: String) : PromptContribution()
@@ -31,8 +30,8 @@ sealed class PromptContribution {
 
 /**
  * Communication surface from a plugin back to the host widget. Plugins use it to act on the host
- * (e.g. [submit]) and to read the host's current [NativeInputState] when their behaviour depends on it,
- * without coupling to the widget class directly.
+ * (e.g. [submit]) without coupling to the widget class directly. State that depends on the active
+ * tab is observed via `NativeInputStateProvider.state` rather than reached for through the host.
  */
 interface NativeInputHost {
     /** Submit the current input as a chat message; opens a new chat session if the input is empty. */
@@ -43,9 +42,6 @@ interface NativeInputHost {
     fun showReasoningPicker(showing: Boolean)
 
     fun attachmentChanged(hasAttachments: Boolean, limitExceeded: Boolean, supportsUpload: Boolean)
-
-    /** Current input state of the host widget (mode, context, position). */
-    fun getInputState(): NativeInputState
 }
 
 interface NativeInputPlugin : ActivePlugin {

duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/nativeinput/RealNativeInputStateStore.kt

@@ -16,27 +16,50 @@
 
 package com.duckduckgo.duckchat.impl.nativeinput
 
+import com.duckduckgo.app.tabs.model.TabRepository
 import com.duckduckgo.di.scopes.AppScope
 import com.duckduckgo.duckchat.api.nativeinput.NativeInputState
 import com.duckduckgo.duckchat.api.nativeinput.NativeInputStateProvider
 import com.duckduckgo.duckchat.api.nativeinput.NativeInputStatePublisher
 import com.squareup.anvil.annotations.ContributesBinding
+import dagger.Lazy
 import dagger.SingleInstanceIn
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.update
 import java.util.concurrent.ConcurrentHashMap
 import javax.inject.Inject
 
+@OptIn(ExperimentalCoroutinesApi::class)
 @SingleInstanceIn(AppScope::class)
 @ContributesBinding(AppScope::class, boundType = NativeInputStateProvider::class)
 @ContributesBinding(AppScope::class, boundType = NativeInputStatePublisher::class)
-class RealNativeInputStateStore @Inject constructor() :
+class RealNativeInputStateStore @Inject constructor(
+    // Lazy avoids a Dagger cycle: TabRepository's impl (TabDataRepository) injects
+    // NativeInputStatePublisher to clearTab on tab eviction. Resolving TabRepository
+    // lazily lets Dagger construct both without circularity. The lazy is only
+    // dereferenced when `state` is collected for the first time.
+    private val tabRepository: Lazy<TabRepository>,
+) :
     NativeInputStateProvider,
     NativeInputStatePublisher {
 
     private val flows = ConcurrentHashMap<String, MutableStateFlow<NativeInputState>>()
 
+    override val state: Flow<NativeInputState> by lazy {
+        tabRepository.get().flowSelectedTab
+            .filterNotNull()
+            .map { it.tabId }
+            .distinctUntilChanged()
+            .flatMapLatest { flowFor(it) }
+    }
+
     override fun stateForTab(tabId: String): StateFlow<NativeInputState> = flowFor(tabId)
 
     override fun publish(tabId: String, state: NativeInputState) {
@@ -59,5 +82,5 @@ class RealNativeInputStateStore @Inject constructor() :
     // value. The native input widget overwrites it on configure, so observers should never see this
     // placeholder in practice.
     private fun flowFor(tabId: String): MutableStateFlow<NativeInputState> =
-        flows.computeIfAbsent(tabId) { MutableStateFlow(NativeInputState.zero(tabId)) }
+        flows.computeIfAbsent(tabId) { MutableStateFlow(NativeInputState.zero()) }
 }

duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/ui/NativeInputModeWidgetViewModel.kt

@@ -160,6 +160,10 @@ class NativeInputModeWidgetViewModel @Inject constructor(
     private data class WidgetConfig(
         val inputContext: NativeInputState.InputContext = NativeInputState.InputContext.BROWSER,
         val inputPosition: NativeInputState.InputPosition = NativeInputState.InputPosition.TOP,
+        // null = follow the context-derived default; non-null = user (or widget) has set it explicitly
+        // via setToggleSelection. Reset to null on every configure(), then driven by the widget's
+        // TabLayout listener.
+        val toggleSelection: NativeInputState.ToggleSelection? = null,
     )
 
     private val widgetConfig = MutableStateFlow(WidgetConfig())
@@ -172,12 +176,12 @@ class NativeInputModeWidgetViewModel @Inject constructor(
         duckChatInternal.observeInputScreenUserSettingEnabled(),
         widgetConfig,
         activeTabId.filterNotNull(),
-    ) { isFeatureEnabled, isUserEnabled, isInputScreenUserSettingEnabled, config, tabId ->
+    ) { isFeatureEnabled, isUserEnabled, isInputScreenUserSettingEnabled, config, _ ->
         NativeInputState(
             inputMode = getInputMode(isFeatureEnabled && isUserEnabled, isInputScreenUserSettingEnabled),
             inputContext = config.inputContext,
             inputPosition = config.inputPosition,
-            tabId = tabId,
+            toggleSelection = config.toggleSelection ?: NativeInputState.defaultToggleFor(config.inputContext),
         )
     }.shareIn(
         scope = viewModelScope,
@@ -186,8 +190,26 @@ class NativeInputModeWidgetViewModel @Inject constructor(
     )
 
     init {
+        // Publish only the widget-owned fields via update, leaving plugin-owned contributions (added
+        // later by typed host methods) untouched across widget emissions. This keeps the widget VM
+        // the single writer for its fields without clobbering anything the publisher.update path
+        // wrote on behalf of a plugin.
+        //
+        // Pair each state with the active tabId via combine so the publish target is captured at
+        // emission time rather than read separately from activeTabId.value (which could shift
+        // between emission and read on a fast tab switch).
         viewModelScope.launch {
-            state.collect { nativeInputStatePublisher.publish(it.tabId, it) }
+            combine(state, activeTabId.filterNotNull()) { snapshot, tabId -> tabId to snapshot }
+                .collect { (tabId, snapshot) ->
+                    nativeInputStatePublisher.update(tabId) { current ->
+                        current.copy(
+                            inputMode = snapshot.inputMode,
+                            inputContext = snapshot.inputContext,
+                            inputPosition = snapshot.inputPosition,
+                            toggleSelection = snapshot.toggleSelection,
+                        )
+                    }
+                }
         }
     }
 
@@ -220,6 +242,10 @@ class NativeInputModeWidgetViewModel @Inject constructor(
         widgetConfig.update { it.copy(inputPosition = position) }
     }
 
+    fun setToggleSelection(selection: NativeInputState.ToggleSelection) {
+        widgetConfig.update { it.copy(toggleSelection = selection) }
+    }
+
     fun configure(tabId: String, isDuckAiMode: Boolean, isBottom: Boolean) {
         activeTabId.value = tabId
         val context = if (isDuckAiMode) NativeInputState.InputContext.DUCK_AI else NativeInputState.InputContext.BROWSER

duckchat/duckchat-impl/src/main/java/com/duckduckgo/duckchat/impl/ui/nativeinput/views/ModelPickerView.kt

@@ -41,6 +41,7 @@ import com.duckduckgo.common.ui.view.text.DaxTextView
 import com.duckduckgo.common.utils.ViewViewModelFactory
 import com.duckduckgo.di.scopes.ViewScope
 import com.duckduckgo.duckchat.api.nativeinput.NativeInputState.InputContext
+import com.duckduckgo.duckchat.api.nativeinput.NativeInputStateProvider
 import com.duckduckgo.duckchat.impl.DuckChatConstants.DUCK_AI_FEATURE_PAGE
 import com.duckduckgo.duckchat.impl.R
 import com.duckduckgo.duckchat.impl.models.AIChatModel
@@ -78,14 +79,21 @@ class ModelPickerView @JvmOverloads constructor(
 
     @Inject lateinit var globalActivityStarter: GlobalActivityStarter
 
+    @Inject lateinit var nativeInputStateProvider: NativeInputStateProvider
+
     private val viewModel by lazy {
         ViewModelProvider(findViewTreeViewModelStoreOwner()!!, viewModelFactory)[ModelPickerViewModel::class.java]
     }
     private val chip: Chip by lazy { findViewById(R.id.modelPickerChip) }
     private var stateJob: Job? = null
+    private var inputContextJob: Job? = null
     private var commandJob: Job? = null
     private var popupWindow: PopupWindow? = null
     private var lastObservedModelId: String? = null
+
+    // Mirrors the input context from the per-tab native input state so currentSurface() can be
+    // read synchronously from popup callbacks. Updated by observeInputContext().
+    private var lastInputContext: InputContext = InputContext.BROWSER
     private lateinit var host: NativeInputHost
     override var onMenuShown: (() -> Unit)? = null
     override var onMenuDismissed: (() -> Unit)? = null
@@ -131,6 +139,15 @@ class ModelPickerView @JvmOverloads constructor(
 
         viewModel.fetchModels()
         observeState()
+        observeInputContext()
+    }
+
+    private fun observeInputContext() {
+        val scope = findViewTreeLifecycleOwner()?.lifecycleScope ?: return
+        inputContextJob?.cancel()
+        inputContextJob = nativeInputStateProvider.state
+            .onEach { lastInputContext = it.inputContext }
+            .launchIn(scope)
     }
 
     private fun observeState() {
@@ -165,7 +182,7 @@ class ModelPickerView @JvmOverloads constructor(
     }
 
     private fun currentSurface(): ModelPickerViewModel.PickerSurface =
-        when (host.getInputState().inputContext) {
+        when (lastInputContext) {
             InputContext.DUCK_AI, InputContext.DUCK_AI_CONTEXTUAL -> ModelPickerViewModel.PickerSurface.DUCK_AI_TAB
             InputContext.BROWSER -> ModelPickerViewModel.PickerSurface.ADDRESS_BAR
         }
@@ -230,6 +247,8 @@ class ModelPickerView @JvmOverloads constructor(
         super.onDetachedFromWindow()
         stateJob?.cancel()
         stateJob = null
+        inputContextJob?.cancel()
+        inputContextJob = null
         commandJob?.cancel()
         commandJob = null
         dismissPopup()