Merge pull request Expensify#85620 from Expensify/marcochavezf/612534-fix-stuck-thinking-indicator

[Payment due @situchan] Fix stuck Concierge thinking indicator when client misses Onyx clear update

Author: MonilBhavsar

src/ONYXKEYS.ts

@@ -609,6 +609,9 @@ const ONYXKEYS = {
     /** Company cards custom names */
     NVP_EXPENSIFY_COMPANY_CARDS_CUSTOM_NAMES: 'nvp_expensify_ccCustomNames',
 
+    /** Whether to kick off the "Concierge is thinking" indicator when AgentZeroStatusGate mounts */
+    CONCIERGE_THINKING_KICKOFF: 'conciergeThinkingKickoff',
+
     /** The user's Concierge reportID */
     CONCIERGE_REPORT_ID: 'conciergeReportID',
 
@@ -1541,6 +1544,7 @@ type OnyxValuesMapping = {
     [ONYXKEYS.LAST_ROUTE]: string;
     [ONYXKEYS.IS_USING_IMPORTED_STATE]: boolean;
     [ONYXKEYS.NVP_EXPENSIFY_COMPANY_CARDS_CUSTOM_NAMES]: Record<string, string>;
+    [ONYXKEYS.CONCIERGE_THINKING_KICKOFF]: boolean;
     [ONYXKEYS.CONCIERGE_REPORT_ID]: string;
     [ONYXKEYS.SELF_DM_REPORT_ID]: string;
     [ONYXKEYS.SHARE_UNKNOWN_USER_DETAILS]: Participant;

src/components/Search/SearchRouter/useAskConcierge.tsx

@@ -4,7 +4,7 @@ import useOnyx from '@hooks/useOnyx';
 import useOpenConciergeAnywhere from '@hooks/useOpenConciergeAnywhere';
 import useSidePanelReportID from '@hooks/useSidePanelReportID';
 import getNonEmptyStringOnyxID from '@libs/getNonEmptyStringOnyxID';
-import {addComment} from '@userActions/Report';
+import {addComment, setConciergeThinkingKickoff} from '@userActions/Report';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
 
@@ -29,6 +29,7 @@ function useAskConcierge() {
             return;
         }
         openConciergeAnywhere();
+        setConciergeThinkingKickoff();
         addComment({
             report: targetReport,
             notifyReportID: targetReportID,

src/hooks/useAgentZeroStatusIndicator.ts

@@ -0,0 +1,116 @@
+/**
+ * Ephemeral in-memory store for the optimistic "Concierge is thinking…" state per report.
+ *
+ * The optimistic counter has to survive ReportScreen remounts (switching chats and coming
+ * back) — React state scoped to the mounted provider doesn't. This store holds it at the
+ * module level, keyed by reportID, so the next mount can restore the indicator.
+ *
+ * Transient by nature: cleared on reply detection, safety timeout, reconnect, or by the
+ * caller. Not persisted to Onyx.
+ */
+
+/** Upper bound on how long an optimistic entry stays valid without a server label or reply. */
+const MAX_AGE_MS = 120000;
+
+type OptimisticEntry = {
+    /** Number of pending optimistic kickoffs (one per user message). */
+    count: number;
+
+    /**
+     * Timestamp of the most recent kickoff (ms). Drives the remaining safety window across
+     * remounts. Bumped on every `increment` — matches the in-memory behavior where each
+     * kickoff call to `startPolling` resets the 120s safety timer.
+     */
+    startedAt: number;
+
+    /**
+     * Newest reportActionID captured at the moment the indicator transitioned inactive→active.
+     * Persisted so the Concierge-reply-detection effect still fires after a remount, even if
+     * the reply arrived while the provider was unmounted. Unlike `startedAt`, this stays fixed
+     * at the *first* kickoff's baseline — any new Concierge action afterwards is a new reply.
+     */
+    baselineActionID: string | null;
+};
+
+type Listener = (reportID: string) => void;
+
+const store = new Map<string, OptimisticEntry>();
+const listeners = new Set<Listener>();
+
+function notifyListeners(reportID: string) {
+    for (const listener of listeners) {
+        listener(reportID);
+    }
+}
+
+function isFresh(entry: OptimisticEntry): boolean {
+    return Date.now() - entry.startedAt < MAX_AGE_MS;
+}
+
+/**
+ * Get the current entry for a report, or undefined if none exists or the entry is past
+ * its MAX_AGE_MS window. Stale entries are left in the map — the next increment/clear
+ * will evict them. Callers that care about cleanup can call `clear` imperatively.
+ */
+function getEntry(reportID: string): OptimisticEntry | undefined {
+    const entry = store.get(reportID);
+    if (!entry) {
+        return undefined;
+    }
+    return isFresh(entry) ? entry : undefined;
+}
+
+/**
+ * Increment the pending count for a report, or start a fresh entry if none exists / the
+ * existing one is stale. `baselineActionID` is only recorded on a fresh start — subsequent
+ * kickoffs within the same window keep the original baseline (we care about replies newer
+ * than the *first* optimistic message).
+ *
+ * `startedAt` is bumped on every call so the safety window always measures from the most
+ * recent kickoff — this matches the in-memory `startPolling` behavior where each call
+ * resets the 120s timer.
+ */
+function increment(reportID: string, baselineActionID: string | null) {
+    const existing = store.get(reportID);
+    const now = Date.now();
+    if (existing && isFresh(existing)) {
+        store.set(reportID, {
+            count: existing.count + 1,
+            startedAt: now,
+            baselineActionID: existing.baselineActionID,
+        });
+    } else {
+        store.set(reportID, {
+            count: 1,
+            startedAt: now,
+            baselineActionID,
+        });
+    }
+    notifyListeners(reportID);
+}
+
+/** Drop all optimistic state for a report. Safe to call when no entry exists. */
+function clear(reportID: string) {
+    if (!store.has(reportID)) {
+        return;
+    }
+    store.delete(reportID);
+    notifyListeners(reportID);
+}
+
+function subscribe(listener: Listener): () => void {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+
+export default {
+    getEntry,
+    increment,
+    clear,
+    subscribe,
+};
+
+export {MAX_AGE_MS};
+export type {OptimisticEntry};

src/libs/AgentZeroOptimisticStore.ts

@@ -0,0 +1,127 @@
+/**
+ * Ephemeral in-memory store for managing Concierge reasoning summaries per report.
+ * This data is transient UI feedback and is NOT persisted to Onyx.
+ */
+
+type ReasoningEntry = {
+    reasoning: string;
+    loopCount: number;
+    timestamp: number;
+};
+
+type ReasoningData = {
+    reasoning: string;
+    agentZeroRequestID: string;
+    loopCount: number;
+};
+
+type ReportState = {
+    agentZeroRequestID: string;
+    entries: ReasoningEntry[];
+};
+
+type Listener = (reportID: string, state: ReasoningEntry[]) => void;
+
+// In-memory store
+const store = new Map<string, ReportState>();
+const listeners = new Set<Listener>();
+
+// Stable empty array reference for useSyncExternalStore compatibility.
+// getSnapshot must return the same reference when data hasn't changed,
+// otherwise React will re-render infinitely.
+const EMPTY_ENTRIES: ReasoningEntry[] = [];
+
+/**
+ * Notify all subscribers of state changes
+ */
+function notifyListeners(reportID: string, entries: ReasoningEntry[]) {
+    for (const listener of listeners) {
+        listener(reportID, entries);
+    }
+}
+
+/**
+ * Add a reasoning entry to a report's history.
+ * If the agentZeroRequestID differs from the current state, resets all entries (new request).
+ * Skips duplicates (same loopCount + same reasoning text).
+ */
+function addReasoning(reportID: string, data: ReasoningData) {
+    // Ignore empty reasoning strings
+    if (!data.reasoning.trim()) {
+        return;
+    }
+
+    const currentState = store.get(reportID);
+
+    // If agentZeroRequestID differs, reset all entries (new request)
+    if (currentState && currentState.agentZeroRequestID !== data.agentZeroRequestID) {
+        store.set(reportID, {
+            agentZeroRequestID: data.agentZeroRequestID,
+            entries: [],
+        });
+    }
+
+    // Get or create state
+    const state = store.get(reportID) ?? {
+        agentZeroRequestID: data.agentZeroRequestID,
+        entries: [],
+    };
+
+    // Skip duplicates (same loopCount + same reasoning text)
+    const isDuplicate = state.entries.some((entry) => entry.loopCount === data.loopCount && entry.reasoning === data.reasoning);
+
+    if (!isDuplicate) {
+        const timestamp = Date.now();
+        const newEntries = [
+            ...state.entries,
+            {
+                reasoning: data.reasoning,
+                loopCount: data.loopCount,
+                timestamp,
+            },
+        ];
+        const newState = {
+            agentZeroRequestID: state.agentZeroRequestID,
+            entries: newEntries,
+        };
+        store.set(reportID, newState);
+        notifyListeners(reportID, newEntries);
+    }
+}
+
+/**
+ * Remove all reasoning entries for a report.
+ * Called when the final Concierge message arrives or when unsubscribing.
+ */
+function clearReasoning(reportID: string) {
+    store.delete(reportID);
+    notifyListeners(reportID, []);
+}
+
+/**
+ * Get the reasoning history for a report
+ */
+function getReasoningHistory(reportID: string): ReasoningEntry[] {
+    return store.get(reportID)?.entries ?? EMPTY_ENTRIES;
+}
+
+/**
+ * Subscribe to state changes.
+ * Listener receives (reportID, state) on every change.
+ * Returns an unsubscribe function.
+ */
+function subscribe(listener: Listener): () => void {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+
+export default {
+    addReasoning,
+    clearReasoning,
+    getReasoningHistory,
+    subscribe,
+};
+
+export type {ReasoningEntry, ReasoningData};

src/libs/ConciergeReasoningStore.ts

@@ -64,6 +64,7 @@ import {READ_COMMANDS, SIDE_EFFECT_REQUEST_COMMANDS, WRITE_COMMANDS} from '@libs
 import * as ApiUtils from '@libs/ApiUtils';
 import * as Browser from '@libs/Browser';
 import * as CollectionUtils from '@libs/CollectionUtils';
+import ConciergeReasoningStore from '@libs/ConciergeReasoningStore';
 import type {CustomRNImageManipulatorResult} from '@libs/cropOrRotateImage/types';
 import DateUtils from '@libs/DateUtils';
 import * as EmojiUtils from '@libs/EmojiUtils';
@@ -432,6 +433,10 @@ Onyx.connect({
 
 const typingWatchTimers: Record<string, NodeJS.Timeout> = {};
 
+// Track subscriptions to conciergeReasoning Pusher events to avoid duplicates.
+// Maps reportID to the PusherSubscription handle for proper per-callback cleanup.
+const reasoningSubscriptions = new Map<string, ReturnType<typeof Pusher.subscribe>>();
+
 let reportIDDeeplinkedFromOldDot: string | undefined;
 Linking.getInitialURL().then((url) => {
     reportIDDeeplinkedFromOldDot = processReportIDDeeplink(url ?? '');
@@ -609,6 +614,64 @@ function unsubscribeFromLeavingRoomReportChannel(reportID: string | undefined) {
     Pusher.unsubscribe(pusherChannelName, Pusher.TYPE.USER_IS_LEAVING_ROOM);
 }
 
+/**
+ * Subscribe to conciergeReasoning Pusher events for a report.
+ * Tracks subscriptions to avoid duplicates and updates ConciergeReasoningStore with reasoning data.
+ */
+function subscribeToReportReasoningEvents(reportID: string) {
+    if (!reportID || reasoningSubscriptions.has(reportID)) {
+        return;
+    }
+
+    const pusherChannelName = getReportChannelName(reportID);
+
+    const handle = Pusher.subscribe(pusherChannelName, Pusher.TYPE.CONCIERGE_REASONING, (data: Record<string, unknown>) => {
+        const eventData = data as {reasoning: string; agentZeroRequestID: string; loopCount: number};
+
+        ConciergeReasoningStore.addReasoning(reportID, {
+            reasoning: eventData.reasoning,
+            agentZeroRequestID: eventData.agentZeroRequestID,
+            loopCount: eventData.loopCount,
+        });
+    });
+
+    // Store the handle immediately to prevent duplicate subscriptions
+    reasoningSubscriptions.set(reportID, handle);
+
+    handle.catch((error: ReportError) => {
+        Log.hmmm('[Report] Failed to subscribe to Pusher concierge reasoning events', {errorType: error.type, pusherChannelName, reportID});
+        // Remove from subscriptions if subscription failed
+        reasoningSubscriptions.delete(reportID);
+    });
+}
+
+/**
+ * Unsubscribe from conciergeReasoning Pusher events for a report.
+ * Clears reasoning state and removes from subscription tracking.
+ */
+function unsubscribeFromReportReasoningChannel(reportID: string) {
+    const handle = reasoningSubscriptions.get(reportID);
+    if (!reportID || !handle) {
+        return;
+    }
+
+    // Use the per-callback handle for precise cleanup instead of the global
+    // Pusher.unsubscribe which removes ALL callbacks for the event on the channel.
+    handle.unsubscribe();
+    ConciergeReasoningStore.clearReasoning(reportID);
+    reasoningSubscriptions.delete(reportID);
+}
+
+/**
+ * Clear the AgentZero processing indicator for a report.
+ * Used by the safety timeout (lease pattern) and network reconnect handler
+ * to auto-clear stale indicators when the CLEAR update was missed.
+ */
+function clearAgentZeroProcessingIndicator(reportID: string) {
+    Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${reportID}`, {agentZeroProcessingRequestIndicator: null});
+    ConciergeReasoningStore.clearReasoning(reportID);
+}
+
 // New action subscriber array for report pages
 let newActionSubscribers: ActionSubscriber[] = [];
 
@@ -7612,6 +7675,14 @@ function setOptimisticTransactionThread(reportID?: string, parentReportID?: stri
     });
 }
 
+function setConciergeThinkingKickoff() {
+    Onyx.set(ONYXKEYS.CONCIERGE_THINKING_KICKOFF, true);
+}
+
+function clearConciergeThinkingKickoff() {
+    Onyx.set(ONYXKEYS.CONCIERGE_THINKING_KICKOFF, null);
+}
+
 export type {Video, GuidedSetupData, TaskForParameters, IntroSelected, OpenReportActionParams, ParticipantInfo};
 
 export {
@@ -7693,6 +7764,11 @@ export {
     startNewChat,
     subscribeToNewActionEvent,
     subscribeToReportLeavingEvents,
+    clearAgentZeroProcessingIndicator,
+    clearConciergeThinkingKickoff,
+    setConciergeThinkingKickoff,
+    subscribeToReportReasoningEvents,
+    unsubscribeFromReportReasoningChannel,
     subscribeToReportTypingEvents,
     toggleEmojiReaction,
     togglePinnedState,