Add fire actions to native chat history screen

app/src/main/java/com/duckduckgo/app/fire/DataClearing.kt

@@ -95,17 +95,20 @@ class DataClearing @Inject constructor(
         val clearDataResult = clearDataAction.clearDataForSpecificDomains(visitedSites)
         val tabUrl = tabRepository.getTab(tabId)?.url
 
-        clearDuckAiChatIfNeeded(tabUrl)
-        clearContextualChatDataIfNeeded(tabId)
-        navigationHistory.removeHistoryForTab(tabId)
-
+        // Reset this tab's URL before dispatching the chat clear: the tabs-cleanup plugin matches
+        // tabs by chatID, and we don't want this tab caught by that match — it stays open with a
+        // new chat URL. Other tabs at the same chatID (duplicates) do get closed, which is desired.
         if (replaceCurrentTab) {
             val url = getNewTabUrl(tabUrl)
             tabOperations.replaceTabWithNewTab(tabId, url)
         } else {
             tabRepository.deleteTabs(listOf(tabId))
         }
 
+        clearDuckAiChatIfNeeded(tabUrl)
+        clearContextualChatDataIfNeeded(tabId)
+        navigationHistory.removeHistoryForTab(tabId)
+
         logcat { "Single tab clear completed for tab: $tabId" }
         return clearDataResult
     }
@@ -233,6 +236,12 @@ class DataClearing @Inject constructor(
         return fireDataStore.getAutomaticClearOptions().isNotEmpty()
     }
 
+    override suspend fun clearSelectedDuckAiChats(chatUrls: Set<String>) {
+        if (chatUrls.isEmpty()) return
+        if (!duckAiFeatureState.showClearDuckAIChatHistory.value) return
+        dataClearingTrigger.clearData(setOf(ClearableData.DuckChats.Selected(chatUrls)))
+    }
+
     /**
      * Performs granular data clearing based on the provided options
      * @return true if process needs to be restarted

app/src/main/java/com/duckduckgo/app/fire/DuckAiTabsCleanupPlugin.kt

@@ -0,0 +1,79 @@
+/*
+ * 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.app.fire
+
+import android.net.Uri
+import androidx.core.net.toUri
+import com.duckduckgo.app.tabs.model.TabRepository
+import com.duckduckgo.dataclearing.api.plugin.ClearableData
+import com.duckduckgo.dataclearing.api.plugin.DataClearingPlugin
+import com.duckduckgo.di.scopes.AppScope
+import com.duckduckgo.duckchat.api.DuckChat
+import com.squareup.anvil.annotations.ContributesMultibinding
+import logcat.logcat
+import javax.inject.Inject
+
+/** Closes Duck.ai tabs left pointing at cleared chat URLs. Never touches non-Duck.ai tabs. */
+@ContributesMultibinding(AppScope::class)
+class DuckAiTabsCleanupPlugin @Inject constructor(
+    private val tabRepository: TabRepository,
+    private val duckChat: DuckChat,
+) : DataClearingPlugin {
+
+    override suspend fun onClearData(types: Set<ClearableData>) {
+        types.forEach { type ->
+            when (type) {
+                is ClearableData.DuckChats.All -> closeAllDuckAiTabs()
+                is ClearableData.DuckChats.Selected -> closeTabsMatching(type.chatUrls)
+                else -> { /* not handled by this plugin */ }
+            }
+        }
+    }
+
+    private suspend fun closeAllDuckAiTabs() {
+        val ids = tabRepository.getTabs()
+            .filter { tab -> tab.url?.toUri()?.let(duckChat::isDuckChatUrl) == true }
+            .map { it.tabId }
+        if (ids.isNotEmpty()) {
+            logcat { "Closing ${ids.size} open Duck.ai tab(s) after chat clear" }
+            tabRepository.deleteTabs(ids)
+        }
+    }
+
+    /**
+     * Match by `chatID` query param rather than full URL equality — tabs drift (server redirects,
+     * extra query params accumulated during the session) so multiple tabs of the same chat would
+     * otherwise miss the match.
+     */
+    private suspend fun closeTabsMatching(chatUrls: Set<String>) {
+        if (chatUrls.isEmpty()) return
+        val targetChatIds = chatUrls.mapNotNullTo(mutableSetOf()) { it.toUri().chatIdOrNull() }
+        if (targetChatIds.isEmpty()) return
+        val ids = tabRepository.getTabs()
+            .filter { tab -> tab.url?.toUri()?.chatIdOrNull() in targetChatIds }
+            .map { it.tabId }
+        if (ids.isNotEmpty()) {
+            logcat { "Closing ${ids.size} Duck.ai tab(s) matching the cleared subset" }
+            tabRepository.deleteTabs(ids)
+        }
+    }
+
+    private fun Uri.chatIdOrNull(): String? {
+        if (!duckChat.isDuckChatUrl(this)) return null
+        return getQueryParameter("chatID")?.takeIf { it.isNotBlank() }
+    }
+}

app/src/main/java/com/duckduckgo/app/fire/ManualDataClearing.kt

@@ -29,6 +29,9 @@ interface ManualDataClearing {
      */
     suspend fun clearDataUsingManualFireOptions(shouldRestartIfRequired: Boolean = false, wasAppUsedSinceLastClear: Boolean = false)
 
+    /** Deletes only the chats addressed by [chatUrls] and closes any browser tabs pointing at them. */
+    suspend fun clearSelectedDuckAiChats(chatUrls: Set<String>)
+
     /**
      * Clears all data associated with tab:
      * site browsing data (via WebStorageCompat), tab-specific history,

app/src/main/java/com/duckduckgo/app/global/view/SingleTabFireDialog.kt

@@ -72,11 +72,13 @@ private const val BOTTOM_SHEET_MAX_WIDTH_DP = 640
 private const val NO_MAX_WIDTH = -1
 private const val ARG_ORIGIN = "origin"
 private const val ARG_TAB_ID = "tabId"
+private const val ARG_SELECTED_CHAT_URLS = "selectedChatUrls"
 internal const val ORIGIN_BROWSER = "Browser"
 internal const val ORIGIN_SETTINGS = "Settings"
 internal const val ORIGIN_TAB_SWITCHER = "TabSwitcher"
 internal const val ORIGIN_DUCK_AI_CONTEXTUAL_CHAT = "DuckAiContextualChat"
 internal const val ORIGIN_HATCH = "Hatch"
+internal const val ORIGIN_CHAT_HISTORY = "ChatHistory"
 
 @InjectWith(FragmentScope::class)
 class SingleTabFireDialog : BottomSheetDialogFragment(), FireDialog {
@@ -174,18 +176,26 @@ class SingleTabFireDialog : BottomSheetDialogFragment(), FireDialog {
     private fun setupLayout() {
         binding.deleteAllPrimaryButton.setOnClickListener {
             hideDialog()
-            viewModel.onDeleteAllClicked()
+            dispatchDeleteAll()
         }
         binding.deleteAllSecondaryButton.setOnClickListener {
             hideDialog()
-            viewModel.onDeleteAllClicked()
+            dispatchDeleteAll()
         }
         binding.deleteThisTabButton.setOnClickListener {
             hideDialog()
             viewModel.onDeleteThisTabClicked()
         }
     }
 
+    private fun dispatchDeleteAll() {
+        if (arguments?.getString(ARG_ORIGIN) == ORIGIN_CHAT_HISTORY) {
+            viewModel.onDeleteSelectedChatsClicked()
+        } else {
+            viewModel.onDeleteAllClicked()
+        }
+    }
+
     private fun configureBottomSheet() {
         (dialog as? BottomSheetDialog)?.behavior?.apply {
             state = BottomSheetBehavior.STATE_EXPANDED
@@ -271,14 +281,11 @@ class SingleTabFireDialog : BottomSheetDialogFragment(), FireDialog {
             binding.fireIcon.gone()
         }
 
-        val titleRes = if (state.stateData.isDuckAiTab && state.isDeleteThisTabButtonVisible) {
-            R.string.singleTabFireDialogTitleDuckAi
-        } else if (state.stateData.isDuckAiChatsSelected) {
-            R.string.singleTabFireDialogTitleWithChats
-        } else {
-            R.string.singleTabFireDialogTitle
+        binding.dialogTitle.text = when (val source = state.stateData.titleSource) {
+            is SingleTabFireDialogViewModel.TitleSource.Static -> requireContext().getString(source.resId)
+            is SingleTabFireDialogViewModel.TitleSource.Plural ->
+                resources.getQuantityString(source.pluralsId, source.count, source.count)
         }
-        binding.dialogTitle.text = requireContext().getString(titleRes)
 
         if (state.isDeleteThisTabButtonVisible) {
             binding.deleteThisTabButton.show()
@@ -439,6 +446,10 @@ class SingleTabFireDialog : BottomSheetDialogFragment(), FireDialog {
                     FireDialogProvider.FireDialogOrigin.Browser
                 }
             }
+            ORIGIN_CHAT_HISTORY -> {
+                val urls = arguments?.getStringArrayList(ARG_SELECTED_CHAT_URLS)?.toSet().orEmpty()
+                FireDialogProvider.FireDialogOrigin.ChatHistory(selectedChatUrls = urls)
+            }
             else -> FireDialogProvider.FireDialogOrigin.Browser
         }
     }
@@ -449,6 +460,8 @@ class SingleTabFireDialog : BottomSheetDialogFragment(), FireDialog {
                 arguments = bundleOf(
                     ARG_ORIGIN to origin.tag(),
                     ARG_TAB_ID to (origin as? FireDialogProvider.FireDialogOrigin.Hatch)?.tabId,
+                    ARG_SELECTED_CHAT_URLS to (origin as? FireDialogProvider.FireDialogOrigin.ChatHistory)
+                        ?.selectedChatUrls?.let { ArrayList(it) },
                 )
             }
         }
@@ -459,6 +472,7 @@ class SingleTabFireDialog : BottomSheetDialogFragment(), FireDialog {
             FireDialogProvider.FireDialogOrigin.TabSwitcher -> ORIGIN_TAB_SWITCHER
             FireDialogProvider.FireDialogOrigin.DuckAiContextualChat -> ORIGIN_DUCK_AI_CONTEXTUAL_CHAT
             is FireDialogProvider.FireDialogOrigin.Hatch -> ORIGIN_HATCH
+            is FireDialogProvider.FireDialogOrigin.ChatHistory -> ORIGIN_CHAT_HISTORY
         }
     }
 }

app/src/main/java/com/duckduckgo/app/global/view/SingleTabFireDialogViewModel.kt

@@ -20,6 +20,7 @@ import androidx.core.net.toUri
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.duckduckgo.anvil.annotations.ContributesViewModel
+import com.duckduckgo.app.browser.R
 import com.duckduckgo.app.browser.api.WebViewCapabilityChecker
 import com.duckduckgo.app.browser.api.WebViewCapabilityChecker.WebViewCapability.DeleteBrowsingData
 import com.duckduckgo.app.fire.ManualDataClearing
@@ -163,6 +164,27 @@ class SingleTabFireDialogViewModel @Inject constructor(
         }
     }
 
+    fun onDeleteSelectedChatsClicked() {
+        val selectedChatUrls = (origin.value as? FireDialogOrigin.ChatHistory)?.selectedChatUrls ?: return
+        viewModelScope.launch {
+            shouldRestartAfterClearing = false
+            command.send(Command.OnClearStarted)
+
+            val fireAnimationEnabled = withContext(dispatcherProvider.io()) {
+                settingsDataStore.fireAnimationEnabled
+            }
+            if (fireAnimationEnabled) {
+                command.send(Command.PlayAnimation)
+            }
+
+            withContext(dispatcherProvider.io()) {
+                dataClearing.clearSelectedDuckAiChats(selectedChatUrls)
+            }
+
+            command.send(Command.ClearingComplete)
+        }
+    }
+
     fun onDeleteThisTabClicked() {
         viewModelScope.launch {
             shouldRestartAfterClearing = false
@@ -230,28 +252,51 @@ class SingleTabFireDialogViewModel @Inject constructor(
     }
 
     private suspend fun mapToViewState(dialogOrigin: FireDialogOrigin): ViewState.Loaded {
+        // Non-tab origins skip the tab/download/WebView probes — there's no tab to reason about.
+        val isTabAware = dialogOrigin !is FireDialogOrigin.ChatHistory
+
         val isDuckAiChatsSelected =
-            fireDataStore.isManualClearOptionSelected(FireClearOption.DUCKAI_CHATS)
-        val isDeleteBrowsingDataSupported = webViewCapabilityChecker.isSupported(DeleteBrowsingData)
-        val shownCount = settingsDataStore.singleTabFireDialogShownCount
-        val downloads = downloadsRepository.getDownloads()
-        val targetTabUrl = resolveTargetTabUrl(dialogOrigin)
+            isTabAware && fireDataStore.isManualClearOptionSelected(FireClearOption.DUCKAI_CHATS)
+        val isDeleteBrowsingDataSupported = isTabAware && webViewCapabilityChecker.isSupported(DeleteBrowsingData)
+        val downloads = if (isTabAware) downloadsRepository.getDownloads() else emptyList()
+        val targetTabUrl = if (isTabAware) resolveTargetTabUrl(dialogOrigin) else null
+        val tabCount = if (isTabAware) tabRepository.getOpenTabCount() else 0
         val isDuckAiTab = dialogOrigin == DuckAiContextualChat ||
-            targetTabUrl?.let { duckChat.isDuckChatUrl(it.toUri()) } ?: false
-        val tabCount = tabRepository.getOpenTabCount()
+            targetTabUrl?.let { duckChat.isDuckChatUrl(it.toUri()) } == true
         val isFireAnimationUpdateEnabled = withContext(dispatcherProvider.io()) {
             brandDesignUpdateToggles.fireAnimationUpdate().isEnabled()
         }
+        val isDeleteThisTabAvailable = (isDeleteBrowsingDataSupported && dialogOrigin == Browser) ||
+            dialogOrigin == DuckAiContextualChat ||
+            dialogOrigin is Hatch
+        val shownCount = settingsDataStore.singleTabFireDialogShownCount
+
+        val titleSource: TitleSource = when (dialogOrigin) {
+            is FireDialogOrigin.ChatHistory -> TitleSource.Plural(
+                pluralsId = R.plurals.fireDialogDeleteCountTitle,
+                count = dialogOrigin.count,
+            )
+            else -> {
+                val titleResId = when {
+                    isDuckAiTab && isDeleteThisTabAvailable -> R.string.singleTabFireDialogTitleDuckAi
+                    isDuckAiChatsSelected -> R.string.singleTabFireDialogTitleWithChats
+                    else -> R.string.singleTabFireDialogTitle
+                }
+                TitleSource.Static(titleResId)
+            }
+        }
+
         return ViewState.Loaded(
             stateData = ViewState.Loaded.StateData(
                 isDuckAiChatsSelected = isDuckAiChatsSelected,
                 isSingleTabEnabled = isDeleteBrowsingDataSupported,
                 isDuckAiTab = isDuckAiTab,
                 tabCount = tabCount,
-                isSiteDataSubtitleEligible = shownCount < DIALOG_WARNING_MESSAGE_SHOWN_LIMIT,
+                isSiteDataSubtitleEligible = isTabAware && shownCount < DIALOG_WARNING_MESSAGE_SHOWN_LIMIT,
                 isDownloadsSubtitleEligible = downloads.any { download -> download.downloadStatus == DownloadStatus.STARTED },
                 isFirePictogramVisible = settingsDataStore.fireAnimationEnabled,
                 isFireAnimationUpdateEnabled = isFireAnimationUpdateEnabled,
+                titleSource = titleSource,
             ),
             origin = dialogOrigin,
         )
@@ -322,10 +367,16 @@ class SingleTabFireDialogViewModel @Inject constructor(
                 val isDownloadsSubtitleEligible: Boolean = false,
                 val isFirePictogramVisible: Boolean = true,
                 val isFireAnimationUpdateEnabled: Boolean = false,
+                val titleSource: TitleSource = TitleSource.Static(R.string.singleTabFireDialogTitle),
             )
         }
     }
 
+    sealed class TitleSource {
+        data class Static(val resId: Int) : TitleSource()
+        data class Plural(val pluralsId: Int, val count: Int) : TitleSource()
+    }
+
     sealed class Command {
         data object PlayAnimation : Command()
         data object ClearingComplete : Command()

app/src/main/res/values/donottranslate.xml

@@ -129,4 +129,9 @@
     <!-- Fire animation rollout: relabel HeroFire to "Inferno Classic" when fireAnimationUpdate is on — pending translation -->
     <string name="settingsHeroFireAnimationClassic">Inferno Classic</string>
     <string name="settingsInfernoAnimation">Inferno</string>
+
+    <plurals name="fireDialogDeleteCountTitle">
+        <item quantity="one" instruction="%1$d is the number of chats the user is about to delete.">Delete %1$d chat?</item>
+        <item quantity="other" instruction="%1$d is the number of chats the user is about to delete.">Delete %1$d chats?</item>
+    </plurals>
 </resources>