Skip to content

[Due for payment 2026-08-12] [$250] No error is displayed when creating a chat with failing network request #95864

Closed

Description

@vincdargento

If you haven’t already, check out our contributing guidelines for onboarding and email contributors@expensify.com to request to join our Slack channel!


Version Number: v9.4.33-1
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from TestRail: https://github.com/Expensify/Expensify/issues/641717
Email or phone of affected tester (no customers): N/A
Issue reported by: Applause Internal Team

Action Performed:

  1. Enable "Simulate failing network requests"
  2. Go to Inbox
  3. Press the global create button > Start chat
  4. Start a chat with a user you never chatted with before

Expected Result:

The chat creation should fail and an error should be shown

Actual Result:

App turns to offline mode and no error is displayed when creating a chat with "Simulate failing network requests"

Workaround:

N/A

Platforms:

  • Android: App
  • Android: mWeb Chrome
  • iOS: App
  • iOS: mWeb Safari
  • iOS: mWeb Chrome
  • Windows: Chrome
  • MacOS: Chrome / Safari

Screenshots/Videos

Bug7181975_1781590392345.bandicam_2026-06-16_09-04-46-628.mp4
Upwork Automation - Do Not Edit
Issue OwnerCurrent Issue Owner: @mallenexpensify

Activity

  1. added
    BugSomething is broken. Auto assigns a BugZero manager.
    on Jul 10, 2026
  2. MelvinBot commented on Jul 10, 2026

    @MelvinBot
    Contributor

    Proposal

    What is the root cause of that problem?

    Two things combine here — one is arguably by-design, the other is a real gap:

    1. "Simulate failing network requests" gets converted into offline mode. The dev tool only sets a shouldFailAllRequests flag (Network.ts:16), which makes every HTTP call throw FAILED_TO_FETCH (HttpUtils.ts:111) — indistinguishable from a real outage. The FailureTracker counts these and, after 3 failures in 10s, fires a sustained-failure hard stop (FailureTracker.ts:54) that flips getIsOffline() to true (NetworkState.ts:36). That is why the app "turns to offline mode."

    2. New-chat creation is an optimistic write with no error path. Starting a chat with a new user calls openReport with a newReportObject — a WRITE command that is queued optimistically (Report/index.ts:2326). Once the app is offline, SequentialQueue stops processing and the request just waits (SequentialQueue.ts:152) — the chat shows a normal pending/greyed state (pendingFields.createChat = ADD), which looks exactly like normal offline optimistic behavior. Critically, the failureData for a brand-new DM never sets errorFields.createChat (unlike new threads, which do set errorFields.createChatThread). So even if the request had failed while still online, no red-brick error would ever appear for a new DM.

    Full data flow & evidence
    1. navigateToAndOpenReport → getChatByParticipants empty → createAndOpenNewOptimisticChat → openReport({newReportObject}) + immediate navigate into the chat.
    2. openReport builds optimistic data with pendingFields.createChat = ADD (Report/index.ts:1753) and calls API.paginate(WRITE, OPEN_REPORT, ...).
    3. Request runs → HttpUtils throws FAILED_TO_FETCH → FailureTracking middleware records it (FailureTracking.ts:21).
    4. 3 failures / 10s → sustained hard stop → app offline → SequentialQueue returns early → queued OpenReport never re-runs.
    5. New-DM failureData has no createChat error field → no error UI. Chat stays "pending."

    Thresholds: COUNT: 3, WINDOW_MS: 10000 in CONST/index.ts.

    What changes do you think we should make in order to solve the problem?

    First, a product decision is needed: is this actually a bug, or working-as-intended? Because the FailureTracker deliberately treats failing requests as an outage, the app entering offline mode — and then queuing the new chat silently, the same as any other offline optimistic write — is the current intended offline-first behavior. Under that lens, "no error shown" is expected: the chat is queued and will be created when connectivity returns.

    If product decides a new-chat creation failure should surface an error to the user, the fix is to add a createChat error path for new DMs, mirroring the existing new-thread handling: push errorFields.createChat into the failureData in the new-report branch of openReport (around Report/index.ts:1855), and render it via the report's existing red-brick-road UI. Note this alone won't change the simulate-failing repro, because the sustained-failure detection makes the app offline before the error can apply — so this only helps genuine online-but-failing responses.

    What alternative solutions did you explore? (Optional)

    Close as WAI if the offline-conversion behavior is intended and offline chat-queueing is the desired UX.


    Confidence: Medium — the code mechanism is confirmed with file:line evidence (high), but whether the observed behavior is a bug vs. intended offline-first behavior is a product/design call the mechanism can't settle.


    Next Steps for Contributor+ team:
    To accept: @MelvinBot implement [this](https://github.com/Expensify/App/issues/95864) to create a draft PR.
    To refine: @MelvinBot <your feedback>
    To reject: Explain why you are rejecting Melvin's proposal.

  3. added
    ExternalAdded to denote the issue can be worked on by a contributor
    on Jul 10, 2026
  4. added
    Help WantedApply this label when an issue is open to proposals by contributors
    on Jul 10, 2026
  5. MobileMage commented on Jul 10, 2026

    @MobileMage
    Contributor

    🚨 Edited by proposal-police: This proposal was edited at 2026-07-11 00:57:23 UTC.

    Proposal

    Please re-state the problem that we are trying to solve in this issue.

    With the "Simulate failing network requests" test tool enabled, starting a chat with a brand-new user (global create > Start chat) creates the chat optimistically but never surfaces any error when the server call fails. The app just drifts into offline mode and the new chat sits in a silent pending state, so the tester has no indication that creation failed.

    What is the root cause of that problem?

    The "Start chat" flow runs navigateToAndOpenReport in NewChatPage/index.tsx (line 396), which for a new participant calls createAndOpenNewOptimisticChat and dispatches openReport with a newReportObject. openReport builds the optimistic report with pendingFields.createChat = ADD and fires OPEN_REPORT as a persisted WRITE via API.paginate. The test tool works by making every request through HttpUtils throw FAILED_TO_FETCH (HttpUtils.ts line ~110), which is the exact same signal as a genuine offline request. When the OPEN_REPORT request is processed and throws, the SequentialQueue takes its shouldFailAllRequests branch and applies the request's failureData before dropping it:

    if (error.name === CONST.ERROR.REQUEST_CANCELLED || error.message === CONST.ERROR.DUPLICATE_RECORD || shouldFailAllRequests) {
    if (shouldFailAllRequests) {
    const onyxUpdates = [...(requestToProcess.failureData ?? []), ...(requestToProcess.finallyData ?? [])] as AnyOnyxUpdate[];

    So failureData is applied. The real gap is what that failureData contains. For a brand-new DM, openReport's isCreatingNewReport branch only clears the loading flag and rolls back the optimistic personal details — it never writes any error onto the report:

    failureData.push({
    onyxMethod: Onyx.METHOD.MERGE,
    key: ONYXKEYS.PERSONAL_DETAILS_LIST,
    value: settledPersonalDetails,
    });

    Because no errorFields.createChat is set, the optimistic report is left with pendingFields.createChat still ADD and zero errors. getCreationReportErrors/getAllReportErrors in ReportUtils.ts therefore find nothing, so the LHN shows no red brick road and the ReportHeader OfflineWithFeedback (which reads getReportOfflinePendingActionAndErrors) renders only a grey pending state. That is the "no error" symptom. The separate "turns offline" symptom comes from the same signal: repeated FAILED_TO_FETCH outcomes accumulate in FailureTracker and flip sustainedFailuresActive once at least 3 failures have occurred and 10 seconds have elapsed since the first one (CONST.NETWORK.SUSTAINED_FAILURE_*). That flip is mostly cosmetic, but it has one consequence that matters for this bug: once it happens, SequentialQueue stops processing (push parks new writes at SequentialQueue.ts lines 596-603 and process returns early at 152-155), so in a slow run the OPEN_REPORT write can be parked before its failureData is ever applied, and even a correct error field would not render until reconnect. A complete fix has to cover both timings, which the second change below does.

    Notably the workspace-member-chat creation path already does this correctly — its failure handler sets errorFields.createChat, which is why that flow shows an error and the DM flow does not:

    value: {
    errorFields: {
    createChat: ErrorUtils.getMicroSecondOnyxErrorWithTranslationKey('report.genericCreateReportFailureMessage'),
    },
    },

    I reproduced this by starting a chat with a brand-new participant while all outgoing requests are set to fail, and the new DM lands in the LHN in a grey pending state with no red brick road and no error banner anywhere in the UI. Checking the underlying report data afterward, the optimistic report still carries pendingFields.createChat set to 'add' with no error fields attached at all, so the state was written correctly and nothing threw or logged an error, yet the UI gives the user no way to notice or retry the failed chat. That traces exactly to openReport's isCreatingNewReport failure handling in src/libs/actions/Report/index.ts, which on failure clears isLoadingInitialReportActions and rolls back the optimistic personal details but never sets errorFields.createChat for a plain DM, unlike the workspace-chat failure path in src/libs/actions/Policy/Policy.ts, which does push errorFields.createChat. Because nothing ever writes that error field, the report has no mechanism to signal failure and the chat just sits there looking like it's still loading.

    What changes do you think we should make in order to solve the problem?

    Add the missing error to openReport's failureData inside the isCreatingNewReport block (right next to the existing personal-details rollback at Report/index.ts line 1855), mirroring the established workspace-chat pattern:

    failureData.push({
        onyxMethod: Onyx.METHOD.MERGE,
        key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
        value: {errorFields: {createChat: getMicroSecondOnyxErrorWithTranslationKey('report.genericCreateReportFailureMessage')}},
    });

    The helper and translation key already exist and are used one branch above for the createChatThread case, so no new strings are needed. This makes a failed create surface a red brick road on the chat via getAllReportErrors (LHN indicator) and via getCreationReportErrors in ReportHeader, which is exactly "an error should be shown." The change is scoped by the isCreatingNewReport guard so it only fires when we actually force a new report — the re-open/existing-chat path in navigateToAndOpenReport (which calls openReport without newReportObject) is unaffected. It is also safe for genuine offline: the queue returns early and never applies failureData while offline (SequentialQueue.ts line 152), so the error only appears when the request truly reaches the server and fails, not while a chat is legitimately queued for later sync.

    Second, to make the reported repro deterministic regardless of timing, guard the FailureTracking middleware so simulated failures don't feed the sustained-failure detector: skip recordFailure() while shouldFailAllRequests is enabled, via an Onyx.connectWithoutView on ONYXKEYS.NETWORK inside FailureTracking.ts, mirroring what SequentialQueue.ts lines 33-43 already do for the same flag. Without this, a run where 3+ requests fail and more than 10 seconds pass before the chat is confirmed flips the app offline first and parks the OPEN_REPORT write, so no error can render (the parked request does self-heal on tool-off via NetworkState.setFailAllRequests, but the tester sees nothing in the meantime). With the guard, the app stays online under simulation, the write always reaches the shouldFailAllRequests branch (SequentialQueue.ts lines 228-236) that applies failureData on the first failure with no retry loop, and the new errorFields.createChat renders every time. Offline simulation remains available through the separate "Force offline" tool, and the existing recovery in NetworkState.setFailAllRequests becomes a harmless backstop. The guard alone would not fix the issue, since applied failureData writes no error field today; the errorFields.createChat addition above stays the load-bearing change.

    What alternative solutions did you explore? (Optional)

    I considered also clearing pendingFields.createChat in failureData, but the workspace-chat precedent deliberately leaves it set so the RBR renders over the pending row, and OfflineWithFeedback already prioritizes the error state, so clearing it is unnecessary and would diverge from the existing pattern.

  6. David-2002065 commented on Jul 10, 2026

    @David-2002065
    Contributor

    Proposal

    Please re-state the problem that we are trying to solve in this issue.

    When "Simulate failing network requests" is enabled and you start a chat with a user you've never chatted with before, the chat creation request fails but no error is surfaced — the optimistic chat stays in place and the app just slips into offline mode.

    What is the root cause of that problem?

    With "Simulate failing network requests" on, the SequentialQueue does handle the failure correctly for persisted writes: it applies the request's failureData and drops the request instead of retrying, so an error would be shown if one were defined:
    https://github.com/Expensify/App/blob/7e6a5f5a97136ee8e8c546b75df8a9be5a3dba07/src/libs/Network/SequentialQueue.ts#L228-L235

    Starting a chat with a new user goes through navigateToAndOpenReport → openReport with a newReportObject, which is a persisted OPEN_REPORT write. openReport optimistically marks the new report with pendingFields.createChat = ADD:
    https://github.com/Expensify/App/blob/7e6a5f5a97136ee8e8c546b75df8a9be5a3dba07/src/libs/actions/Report/index.ts#L1753-L1766

    But its failureData only attaches a create-failure error when the report is a new thread — it never sets one for a plain new chat:
    https://github.com/Expensify/App/blob/7e6a5f5a97136ee8e8c546b75df8a9be5a3dba07/src/libs/actions/Report/index.ts#L1610-L1616

    A brand-new 1:1 chat has isCreatingNewReport === true but isNewThread === false:
    https://github.com/Expensify/App/blob/7e6a5f5a97136ee8e8c546b75df8a9be5a3dba07/src/libs/actions/Report/index.ts#L1518

    So when OPEN_REPORT fails, the queue applies failureData that contains no error for the report — pendingFields.createChat is left as ADD with no matching errorFields.createChat. The optimistic chat therefore renders as perpetually pending (offline-styled) instead of failed, and no RBR error is shown. createGroupChat builds its own failureData and has the exact same gap:
    https://github.com/Expensify/App/blob/7e6a5f5a97136ee8e8c546b75df8a9be5a3dba07/src/libs/actions/Report/index.ts#L2017-L2035

    The report-error surfaces already read this field, so once errorFields.createChat is set the RBR renders automatically — both the generic aggregator and the report-level error getter consume it:
    https://github.com/Expensify/App/blob/7e6a5f5a97136ee8e8c546b75df8a9be5a3dba07/src/libs/ReportUtils.ts#L9436-L9459
    https://github.com/Expensify/App/blob/7e6a5f5a97136ee8e8c546b75df8a9be5a3dba07/src/libs/ReportUtils.ts#L10266

    What changes do you think we should make in order to solve the problem?

    Set a create-failure error on the report in failureData whenever we optimistically create a new chat — mirroring the createChatThread error that already exists for threads, and the addWorkspaceRoom error used for rooms.

    In openReport, inside the existing isCreatingNewReport block (the same block that sets pendingFields.createChat), add to failureData:

    failureData.push({
        onyxMethod: Onyx.METHOD.MERGE,
        key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
        value: {errorFields: {createChat: getMicroSecondOnyxErrorWithTranslationKey('report.genericCreateReportFailureMessage')}},
    });

    createGroupChat doesn't go through that path, so apply the same push to its failureData (keyed on the group reportID).

    Because the success path already clears errorFields.createChat (and pendingFields.createChat), a successful creation won't latch the error — it only appears on a real failure, which keeps offline-first creation intact. getAllReportErrors aggregates every errorFields key and getReportRBRErrors reads errorFields.createChat directly, so no rendering change is needed — the RBR appears on the failed chat with the message "Unexpected error creating this chat. Please try again later."

    What specific scenarios should we cover in the automated test to prevent this bug from happening again in the future?

    • openReport with a newReportObject (new 1:1 chat): after failureData is applied, the report has errorFields.createChat set, and getAllReportErrors returns that error for the report.
    • createGroupChat: on failure, the group report has errorFields.createChat set and surfaces via the RBR.
    • Success path: after successData is applied, errorFields.createChat and pendingFields.createChat are both cleared (no error latched on success).
    • Regression guard for threads: creating a new thread still surfaces a create error on failure.

    What alternative solutions did you explore? (Optional)

    • Instead of adding a new push, broaden the existing isNewThread guard to isCreatingNewReport and reuse a single createChat key for both chats and threads (dropping the separate createChatThread push). It's less duplication, but createChatThread is consumed directly here:
      https://github.com/Expensify/App/blob/7e6a5f5a97136ee8e8c546b75df8a9be5a3dba07/src/pages/inbox/report/ReportActionItemParentAction.tsx#L135
      so collapsing the keys would change the thread's error rendering at that call site. The additive approach keeps both consumers working, which is why I prefer it.
    • Set the create error centrally when an OPEN_REPORT request fails (e.g. keyed off the optimistic pendingFields.createChat) rather than duplicating the push in both openReport and createGroupChat. It's more DRY, but per-action failureData is the established pattern across the codebase and centralizing it is a larger, riskier refactor for a targeted bug — so I'd keep the fix local to the two creation actions.
  7. aswin-s commented on Jul 10, 2026

    @aswin-s
    Contributor

    Proposal

    Please re-state the problem that we are trying to solve in this issue.

    On Web (Chrome/Safari), when "Simulate failing network requests" is enabled and the user starts a chat with someone they have never chatted with before, the app silently goes offline-mode and shows no error indicator. The expected behavior is that chat creation should visibly fail with an error on the newly created chat (matching the pattern used for isNewThread and other new-report creations).

    What is the root cause of that problem?

    In src/libs/actions/Report/index.ts, openReport builds failureData for a brand-new chat (isCreatingNewReport === true, entered via navigateToAndOpenReport → createAndOpenNewOptimisticChat at lines 2337-2346 passing newReportObject: fallbackChat), but inside the if (isCreatingNewReport) block (lines 1753-1877) it only pushes success/optimistic entries and a personal-details revert into failureData (line 1855). It never pushes an errorFields.createChat write onto the new report's Onyx key on failure — contrast the isNewThread branch at lines 1610-1616 which pushes {errorFields: {createChatThread: ...}}, and the success branch at lines 1836-1838 which is prepared to clear a createChat error that is never written. So when the server call fails, the new chat report has pendingFields.createChat: ADD set optimistically (line 1765) but no errorFields.createChat, leaving the UI with no red-brick-road error to display.

    What changes do you think we should make in order to solve the problem?

    1. In src/libs/actions/Report/index.ts inside the if (isCreatingNewReport) block (~line 1855), push a failureData entry mirroring the isNewThread shape: {onyxMethod: MERGE, key: REPORT_${reportID}, value: {errorFields: {createChat: getMicroSecondOnyxErrorWithTranslationKey('report.genericCreateReportFailureMessage')}, pendingFields: {createChat: null}}} so the optimistic pending state is cleared and an error is surfaced.
    2. Also push a failureData entry for the created report action at REPORT_ACTIONS_${reportID} clearing pendingAction on optimisticCreatedAction.reportActionID and setting errors on it, so the created action is not left stuck in ADD state.
    3. Verify the report-preview / LHN list item consumes errorFields.createChat (the same key the success path already clears at line 1837) so the error dot renders, matching the isNewThread UX.
    4. No changes needed to NewChatPage or navigateToAndOpenReport — the fix is centralized in openReport and automatically covers all callers using newReportObject (lines 2343, 2461, 2587, 3568).

    What alternative solutions did you explore? (Optional)

  8. nabi-ebrahimi commented on Jul 10, 2026

    @nabi-ebrahimi
    Contributor

    Proposal

    What is the root cause of that problem?

    Two independent bugs combine to produce both reported symptoms "app turns to offline mode" and "no error displayed".

    Bug 1 — Simulated failures trip the real offline detector. The "Simulate failing network requests" test tool makes HttpUtils throw FAILED_TO_FETCH for every request HttpUtils.ts:111-114

    App/src/libs/HttpUtils.ts

    Lines 111 to 114 in e6cc804

    if (shouldFailAllRequests || shouldForceOffline) {
    throw new HttpsError({
    message: CONST.ERROR.FAILED_TO_FETCH,
    });
    The FailureTracking middleware treats each of these as a genuine connectivity failure and calls recordFailure() with no guard for the test tool FailureTracking.ts:24-26
    if (isConnectivityError) {
    recordFailure();
    }
    After 3 failures within 10 seconds FailureTracker.ts:48-58
    const thresholdCount = CONST.NETWORK.SUSTAINED_FAILURE_THRESHOLD_COUNT;
    const thresholdWindow = CONST.NETWORK.SUSTAINED_FAILURE_WINDOW_MS;
    console.debug(`[FailureTracker] Failure #${failureCount} (elapsed: ${elapsed}ms, threshold: ${thresholdCount} in ${thresholdWindow}ms)`);
    // Only trigger sustained failure when BOTH count AND time thresholds are met
    if (failureCount >= thresholdCount && elapsed >= thresholdWindow) {
    console.debug('[FailureTracker] Sustained failure threshold reached — triggering hard stop');
    for (const cb of sustainedFailureListeners) {
    cb(true);
    }
    the sustained-failure listener fires and sets sustainedFailuresActive = true in NetworkState NetworkState.ts:34
    onSustainedFailureChange((active) => setSustainedFailures(active));
    making getIsOffline() return true NetworkState.ts:36-37
    function getIsOffline(): boolean {
    return !hasRadio || internetUnreachable || sustainedFailuresActive || shouldForceOffline || simulatedOffline;
    Once the app is offline, SequentialQueue.process() early-returns before it reaches the shouldFailAllRequests branch that applies failureData SequentialQueue.ts:152-154
    if (isOfflineNetwork()) {
    Log.info('[SequentialQueue] Unable to process. We are offline.');
    return Promise.resolve();
    vs SequentialQueue.ts:228-235
    if (error.name === CONST.ERROR.REQUEST_CANCELLED || error.message === CONST.ERROR.DUPLICATE_RECORD || shouldFailAllRequests) {
    if (shouldFailAllRequests) {
    const onyxUpdates = [...(requestToProcess.failureData ?? []), ...(requestToProcess.finallyData ?? [])] as AnyOnyxUpdate[];
    Log.info('[SequentialQueue] Applying failure and finally data because shouldFailAllRequests', false, {
    command: requestToProcess.command,
    updatesCount: onyxUpdates.length,
    });
    Onyx.update(onyxUpdates);
    The OpenReport write is parked as ordinary offline work — never processed, and its error data never applied. The code itself acknowledges this conflation: turning the tool off must explicitly clear the accumulated sustained failures NetworkState.ts:180-191
    function setFailAllRequests(failAll: boolean) {
    failAllRequests = failAll;
    Log.info(`[NetworkState] shouldFailAllRequests set to ${failAll}`);
    if (!failAll && sustainedFailuresActive) {
    sustainedFailuresActive = false;
    resetFailureCounters();
    updateState();
    prevIsInternetReachable = null;
    NetInfo.refresh();
    }

    Bug 2 — New-chat creation has no error in its failure data. Starting a chat with a new user calls navigateToAndOpenReport Report/index.ts:2339-2345

    openReport({
    reportID: fallbackChat.reportID,
    introSelected,
    reportActionID: '',
    participants: buildParticipantInfoFromLogins(userLogins),
    personalDetails,
    newReportObject: fallbackChat,
    which for a user with no existing chat calls openReport with a newReportObject. This sets isCreatingNewReport = true Report/index.ts:1520
    const isCreatingNewReport = !isEmptyObject(newReportObject);
    optimistically marks the report with pendingFields.createChat: ADD ([Report/index.ts:1765-1768 https://github.com/Expensify/App/blob/e6cc80496e503e1ed487e89629e9ea7997c70686/src/libs/actions/Report/index.ts#L1765-L1768 and fires the request. When the request fails, the queue applies failureData. For a new thread, failureData pushes errorFields.createChatThread Report/index.ts:1612-1617 https://github.com/Expensify/App/blob/e6cc80496e503e1ed487e89629e9ea7997c70686/src/libs/actions/Report/index.ts#L1612-L1617 rendered by ReportActionItemParentAction.tsx:135. But for a plain new DM isNewThread is false by default at [Report/index.ts:1500 https://github.com/Expensify/App/blob/e6cc80496e503e1ed487e89629e9ea7997c70686/src/libs/actions/Report/index.ts#L1500 , failureData only rolls back optimistic personal details Report/index.ts:1857-1861 https://github.com/Expensify/App/blob/e6cc80496e503e1ed487e89629e9ea7997c70686/src/libs/actions/Report/index.ts#L1857-L1861 — it never sets errorFields.createChat. The UI already reads this field: ReportActionItemCreated.tsx:67 reads report?.errorFields?.createChat for OfflineWithFeedback, and getCreationReportErrors at ReportUtils.ts:10266-10269 https://github.com/Expensify/App/blob/e6cc80496e503e1ed487e89629e9ea7997c70686/src/libs/ReportUtils.ts#L10266-L10269 aggregates it for the LHN. The field is simply never written on failure. createGroupChat builds its own failureData independently Report/index.ts:2030-2038 https://github.com/Expensify/App/blob/e6cc80496e503e1ed487e89629e9ea7997c70686/src/libs/actions/Report/index.ts#L2030-L2038 and has the exact same gap — it also never sets errorFields.createChat.

    Both bugs must be fixed. Fixing only Bug 1 keeps the app online, sends the request, applies failureData, but that data has no error field to render. Fixing only Bug 2 adds the error field, but the app is already offline so failureData is never applied.

    What changes do you think we should make in order to solve the problem?

    1. Stop the simulate-failing tool from tripping the offline detector.

    Expose the already-tracked failAllRequests flag from NetworkState NetworkState.ts:16

    let failAllRequests = false;
    with a getter, and guard recordFailure() in FailureTracking FailureTracking.ts:24-26
    if (isConnectivityError) {
    recordFailure();
    }
    so simulated failures do not feed the sustained-failure detector. Real FAILED_TO_FETCH and EXPENSIFY_SERVICE_INTERRUPTED failures still count. The guard reads the live in-memory flag (not Onyx) because the middleware runs synchronously in the request pipeline; failAllRequests is already kept current by the NETWORK subscriber NetworkState.ts:414-417
    const currentFailAllRequests = !!network.shouldFailAllRequests;
    if (currentFailAllRequests !== failAllRequests) {
    setFailAllRequests(currentFailAllRequests);
    }
    This is safe because shouldFailAllRequests is a debug tool real users never set — production connectivity detection is completely untouched. The guard is the clean counterpart of the existing setFailAllRequests(false) cleanup at NetworkState.ts:180-191
    function setFailAllRequests(failAll: boolean) {
    failAllRequests = failAll;
    Log.info(`[NetworkState] shouldFailAllRequests set to ${failAll}`);
    if (!failAll && sustainedFailuresActive) {
    sustainedFailuresActive = false;
    resetFailureCounters();
    updateState();
    prevIsInternetReachable = null;
    NetInfo.refresh();
    }

    2. Write the missing createChat error for a failed new DM.

    In openReport, inside the isCreatingNewReport block after the personal-details rollback at Report/index.ts:1857-1861

    failureData.push({
    onyxMethod: Onyx.METHOD.MERGE,
    key: ONYXKEYS.PERSONAL_DETAILS_LIST,
    value: settledPersonalDetails,
    });
    push a failure merge that sets errorFields.createChat with report.genericCreateReportFailureMessage. Scope it to !isNewThread so threads keep using errorFields.createChatThread through their separate rendering path at ReportActionItemParentAction.tsx:135
    report?.errorFields?.createChatThread ?? (report?.errorFields?.createChat ? getMicroSecondOnyxErrorWithTranslationKey('report.genericCreateReportFailureMessage') : null)
    Also clear the optimistic CREATED report action's pendingAction to null — the success path does the same Report/index.ts:1797
    value: {[optimisticCreatedAction.reportActionID]: {pendingAction: null}},
    and without it the action stays stuck in ADD state on failure. The helper and translation key already exist — no new strings needed.

    3. Apply the same error to createGroupChat.

    createGroupChat builds its own failureData array independently from openReport Report/index.ts:2030-2038

    > = [
    {
    onyxMethod: Onyx.METHOD.MERGE,
    key: `${ONYXKEYS.COLLECTION.RAM_ONLY_REPORT_LOADING_STATE}${reportID}`,
    value: {
    isLoadingInitialReportActions: false,
    },
    },
    ];
    Add the same errorFields.createChat push and CREATED action pendingAction cleanup to its failureData array.

    What is deliberately NOT changed:

    • pendingFields.createChat is NOT cleared in failureData. The workspace-chat precedent at Policy.ts:1766-1770
      value: {
      errorFields: {
      createChat: ErrorUtils.getMicroSecondOnyxErrorWithTranslationKey('report.genericCreateReportFailureMessage'),
      },
      },
      deliberately leaves it set so the red-brick-road renders over the pending row. OfflineWithFeedback at ReportActionItemCreated.tsx:66-67
      pendingAction={report?.pendingFields?.addWorkspaceRoom ?? report?.pendingFields?.createChat}
      errors={report?.errorFields?.addWorkspaceRoom ?? report?.errorFields?.createChat}
      already prioritizes the error state over the pending state.
    • isOptimisticReport is NOT flipped to false in failureData. The dismiss/retry handler clearCreateChatError at Report/index.ts:4480-4484
      const metaData = getReportMetadata(report?.reportID);
      const isOptimisticReport = metaData?.isOptimisticReport;
      if (report?.errorFields?.createChat && !isOptimisticReport) {
      clearReportFieldKeyErrors(report.reportID, 'createChat');
      return;
      branches on this flag: if the report is still optimistic, dismissing the error deletes the phantom chat and navigates to Concierge (correct retry behavior). Flipping it would leave a zombie report the server never created.
    • The isNewThread / errorFields.createChatThread path is NOT touched. Thread errors render through ReportActionItemParentAction.tsx:135, a different consumer.

    What alternative solutions did you explore? (Optional)

    • Only fix Bug 2 (add errorFields.createChat in openReport). Insufficient: the exact reported repro has the app already offline, so SequentialQueue exits at SequentialQueue.ts:152
      if (isOfflineNetwork()) {
      before any failureData is applied. The error field is never rendered.
    • Only fix Bug 1 (FailureTracking guard). Insufficient: the app stays online and processes the request, but the applied failureData has no error field to render. The user still sees no error.
    • Centralize the error in the request layer (set errorFields.createChat whenever any OPEN_REPORT write with pendingFields.createChat fails). More DRY, but a larger refactor of per-action failureData — the established pattern across the codebase. Too risky for a targeted fix.
    • Clear pendingFields.createChat in failureData. Rejected: diverges from the workspace-chat precedent at Policy.ts:1766-1770
      value: {
      errorFields: {
      createChat: ErrorUtils.getMicroSecondOnyxErrorWithTranslationKey('report.genericCreateReportFailureMessage'),
      },
      },
      and is unnecessary — OfflineWithFeedback already handles the coexistence of pending and error states correctly.
    • Keep the modal open until OpenReport succeeds. Rejected: covers only one entry point (NewChatPage), duplicates request-failure handling outside the action that owns the optimistic state, and bypasses the established optimistic/OfflineWithFeedback pattern.

    Fixed Demo:

    Image
  9. abbasifaizan70 commented on Jul 10, 2026

    @abbasifaizan70
    Contributor

    Proposal

    Please re-state the problem that we are trying to solve in this issue.

    With the “Simulate failing network requests” test tool enabled, starting a chat with a brand‑new user (global create → Start chat → pick someone you’ve never chatted with) should fail the chat creation and surface an error on the new chat. Instead two things go wrong: the app silently slips into offline mode, and the optimistically‑created chat just sits in a grey pending state with no error (no red‑brick‑road) anywhere in the UI, so the tester has no way to tell that creation failed or to retry it.

    Both halves need to be addressed for the exact reported repro to show an error, and the fix must stay correct for genuine offline, for new threads, for group chats, and for the error‑dismiss/retry path — the edge cases the existing proposals don’t fully cover.

    What is the root cause of that problem?

    There are two independent root causes, plus a set of state‑consistency edge cases that only surface once an error is actually written.

    Part 1 — the reported “app turns to offline mode” symptom

    The test tool makes every request through HttpUtils throw FAILED_TO_FETCH — the exact same signal a real outage produces, so nothing downstream can tell them apart:

    App/src/libs/HttpUtils.ts

    Lines 109 to 115 in 7e6a5f5

    .then((response) => {
    // Test mode where all requests will succeed in the server, but fail to return a response
    if (shouldFailAllRequests || shouldForceOffline) {
    throw new HttpsError({
    message: CONST.ERROR.FAILED_TO_FETCH,
    });
    }

    The FailureTracking middleware treats each of those simulated FAILED_TO_FETCH outcomes as a genuine connectivity failure and feeds it to the FailureTracker — there is no guard for the simulate‑failing tool:

    .catch((error: Error) => {
    const isConnectivityError = error.message === CONST.ERROR.FAILED_TO_FETCH || error.message === CONST.ERROR.EXPENSIFY_SERVICE_INTERRUPTED;
    if (isConnectivityError) {
    recordFailure();
    }
    throw error;
    });

    After enough sustained failures the tracker flips NetworkState, so getIsOffline() returns true — this is literally the “app turns to offline mode” the tester sees:

    onSustainedFailureChange((active) => setSustainedFailures(active));
    function getIsOffline(): boolean {
    return !hasRadio || internetUnreachable || sustainedFailuresActive || shouldForceOffline || simulatedOffline;
    }

    Once the app is considered offline, SequentialQueue.process() early‑returns before it ever reaches the branch that applies a request’s failureData, so the queued OpenReport write is parked as ordinary offline work and its failure handling never runs:

    if (isOfflineNetwork()) {
    Log.info('[SequentialQueue] Unable to process. We are offline.');
    return Promise.resolve();

    (The code already knows the tool conflates itself with a real outage — turning the tool off has to explicitly clear the accumulated sustained failures, confirming this is a known quirk of the simulator, not real offline: src/libs/NetworkState.ts#L180-L184.)

    Part 2 — even when failure data IS applied, a new DM writes no error

    Starting a chat with a new user goes through navigateToAndOpenReport, which calls openReport with a newReportObject — a persisted OPEN_REPORT WRITE:

    openReport({
    reportID: fallbackChat.reportID,
    introSelected,
    reportActionID: '',
    participants: buildParticipantInfoFromLogins(userLogins),
    personalDetails,
    newReportObject: fallbackChat,
    isSelfTourViewed,
    betas,
    });

    openReport optimistically marks the new report with pendingFields.createChat = ADD:

    ...newReportObject,
    pendingFields: shouldAddPendingFields
    ? {
    createChat: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
    }

    But its failureData only pushes a create error when the report is a new thread — never for a plain new DM:

    key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
    value: {errorFields: {createChatThread: getMicroSecondOnyxErrorWithTranslationKey('report.genericCreateReportFailureMessage')}},
    });
    }

    For a brand‑new 1:1 chat isCreatingNewReport === true but isNewThread === false, so the only failure entry written for the report is the optimistic personal‑details rollback — there is no errorFields.createChat:

    failureData.push({
    onyxMethod: Onyx.METHOD.MERGE,
    key: ONYXKEYS.PERSONAL_DETAILS_LIST,
    value: settledPersonalDetails,
    });

    This matters because the queue does apply failureData in its shouldFailAllRequests branch (so an error would render if one were defined — meaning Part 2 is a real gap even after Part 1 is fixed, and even for a genuine online‑but‑failing response):

    // Duplicate records don't need to be retried as they just mean the record already exists on the server
    if (error.name === CONST.ERROR.REQUEST_CANCELLED || error.message === CONST.ERROR.DUPLICATE_RECORD || shouldFailAllRequests) {
    if (shouldFailAllRequests) {
    const onyxUpdates = [...(requestToProcess.failureData ?? []), ...(requestToProcess.finallyData ?? [])] as AnyOnyxUpdate[];
    Log.info('[SequentialQueue] Applying failure and finally data because shouldFailAllRequests', false, {
    command: requestToProcess.command,
    updatesCount: onyxUpdates.length,
    });
    Onyx.update(onyxUpdates);
    }

    And the rendering path already exists — ReportActionItemCreated reads report.errorFields.createChat through OfflineWithFeedback; the field is simply never written on failure:

    return (
    <OfflineWithFeedback
    pendingAction={report?.pendingFields?.addWorkspaceRoom ?? report?.pendingFields?.createChat}
    errors={report?.errorFields?.addWorkspaceRoom ?? report?.errorFields?.createChat}
    errorRowStyles={[styles.ml10, styles.mr2, styles.mb2]}
    onClose={() =>
    clearCreateChatError(
    report,
    conciergeReportID,
    introSelected,
    currentUserAccountID,
    betas,
    isSelfTourViewed,
    reportOwnerPersonalDetail,
    currentUserPersonalDetail,
    conciergePersonalDetail,
    )

    The aggregators that light up the LHN red dot and the report‑level RBR both consume errorFields.createChat, so no UI change is needed once the field is set:

    App/src/libs/ReportUtils.ts

    Lines 10261 to 10266 in 7e6a5f5

    * Return the errors we have when creating a chat, a workspace room, or a new empty report
    */
    function getCreationReportErrors(report: OnyxEntry<Report>): Errors | null | undefined {
    // We are either adding a workspace room, creating a chat, or we're creating a report, it isn't possible for all of these to have errors for the same report at the same time, so
    // simply looking up the first truthy value will get the relevant property if it's set.
    return report?.errorFields?.addWorkspaceRoom ?? report?.errorFields?.createChat ?? report?.errorFields?.createReport;

    Part 3 — edge cases the other proposals miss

    (a) The optimistic CREATED action and isOptimisticReport are left stuck. In the same block, the optimistic CREATED report action is created with pendingAction: ADD and REPORT_METADATA.isOptimisticReport is set to true; both are only reset by successData. On failure neither is touched, so the created action stays grey/pending forever:

    optimisticData.push(
    {
    onyxMethod: Onyx.METHOD.SET,
    key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
    value: {[optimisticCreatedAction.reportActionID]: {...optimisticCreatedAction, pendingAction: shouldAddPendingFields ? CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD : null}},
    },
    {
    onyxMethod: Onyx.METHOD.SET,
    key: `${ONYXKEYS.COLLECTION.REPORT_METADATA}${reportID}`,
    value: {
    isOptimisticReport: true,
    },
    },

    (b) The dismiss/retry path depends on isOptimisticReport — nobody accounts for this. When the user closes the RBR, clearCreateChatError branches on isOptimisticReport: if the error is set and the report is not optimistic it merely clears the error; otherwise it deletes the report and navigates to Concierge:

    const metaData = getReportMetadata(report?.reportID);
    const isOptimisticReport = metaData?.isOptimisticReport;
    if (report?.errorFields?.createChat && !isOptimisticReport) {
    clearReportFieldKeyErrors(report.reportID, 'createChat');
    return;
    }

    This is the subtle part: because a failed brand‑new DM was never created server‑side, we want isOptimisticReport to remain true so that dismissing the error discards the phantom chat (retry = start the chat again). A naïve fix that also merges isOptimisticReport: false (or clears pendingFields.createChat) into failureData would leave a zombie report: dismissing would only clear the error and keep a chat the server never created. So the fix must add the error without flipping that metadata.

    (c) createGroupChat has the identical gap. Group creation from the same Start‑chat surface builds its own failureData that likewise never sets errorFields.createChat, so a failed group chat is silent too:

    OnyxUpdate<
    | typeof ONYXKEYS.COLLECTION.REPORT
    | typeof ONYXKEYS.COLLECTION.REPORT_METADATA
    | typeof ONYXKEYS.NVP_INTRO_SELECTED
    | typeof ONYXKEYS.NVP_ONBOARDING
    | typeof ONYXKEYS.COLLECTION.POLICY
    | typeof ONYXKEYS.PERSONAL_DETAILS_LIST
    | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS
    | typeof ONYXKEYS.COLLECTION.RAM_ONLY_REPORT_LOADING_STATE
    >
    > = [
    {
    onyxMethod: Onyx.METHOD.MERGE,
    key: `${ONYXKEYS.COLLECTION.RAM_ONLY_REPORT_LOADING_STATE}${reportID}`,
    value: {
    isLoadingInitialReportActions: false,
    },
    },
    ];
    // Create optimistic created action

    What changes do you think we should make in order to solve the problem?

    Fix both root causes and handle the Part‑3 edge cases. The original code for every location below is already shown via permalink in the root‑cause section, so only the actual changed/added TypeScript is shown here.

    1. Stop the simulate‑failing tool from tripping the real offline detector

    Expose the live flag from NetworkState (add the getter and export it):

    function getShouldFailAllRequests(): boolean {
        return failAllRequests;
    }
    
    export {
        // ...existing exports...
        getShouldFailAllRequests,
    };

    Then guard recordFailure in FailureTracking so simulated failures don’t feed the sustained‑failure detector, while real FAILED_TO_FETCH / service‑interrupted failures still do:

    .catch((error: Error) => {
        const isConnectivityError = error.message === CONST.ERROR.FAILED_TO_FETCH || error.message === CONST.ERROR.EXPENSIFY_SERVICE_INTERRUPTED;
    
        // Don't let the "Simulate failing network requests" test tool trip the real sustained-failure
        // detector — otherwise the app flips to offline and SequentialQueue never applies failureData.
        if (isConnectivityError && !NetworkState.getShouldFailAllRequests()) {
            recordFailure();
        }
    
        throw error;
    });

    With this, the app stays online, SequentialQueue processes the OpenReport write, hits its shouldFailAllRequests branch, and applies failureData — which now (change 2) carries the create error.

    2. Write the missing createChat error for a failed new DM

    Inside the existing if (isCreatingNewReport) block, right after the personal‑details rollback push (src/libs/actions/Report/index.ts#L1855-L1859), add — scoped so it only fires for a genuinely optimistic new DM, leaving the existing isNewThread path untouched:

    if (shouldAddPendingFields && !isNewThread) {
        failureData.push({
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
            value: {errorFields: {createChat: getMicroSecondOnyxErrorWithTranslationKey('report.genericCreateReportFailureMessage')}},
        });
    
        // Un-stick the optimistic CREATED action so it doesn't render as perpetually pending.
        failureData.push({
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
            value: {[optimisticCreatedAction.reportActionID]: {pendingAction: null}},
        });
    }

    Deliberately not included (Part‑3 edge cases): we do not clear pendingFields.createChat (so the RBR renders over the pending row, matching the workspace‑chat precedent) and we do not merge isOptimisticReport: false, so clearCreateChatError treats a dismissed failure as “discard the never‑created chat” rather than stranding a zombie report. The helper and translation key already exist (used one branch above for createChatThread), so no new strings are needed.

    3. Apply the same error to createGroupChat

    In createGroupChat’s failureData (src/libs/actions/Report/index.ts#L2018-L2038), add:

    failureData.push(
        {
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
            value: {errorFields: {createChat: getMicroSecondOnyxErrorWithTranslationKey('report.genericCreateReportFailureMessage')}},
        },
        {
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
            value: {[optimisticCreatedAction.reportActionID]: {pendingAction: null}},
        },
    );

    Because centralizing on openReport covers every caller that passes a newReportObject (e.g. navigateToAndOpenReport and navigateToAndOpenReportWithAccountIDs), and createGroupChat is the one create‑path that builds its own failureData, these two edits cover all Start‑chat entry points without any UI‑layer or backend change. The success path already clears errorFields.createChat, so a successful create never latches an error, and when the user is genuinely offline SequentialQueue returns early and never applies failureData — so the error only appears on a true failure, not on legitimately queued offline work.

    What specific scenarios should we cover in the automated test to prevent this bug from happening again in the future?

    • FailureTracking: FAILED_TO_FETCH increments the sustained‑failure counter for real connectivity errors, but is not recorded while shouldFailAllRequests is enabled.
    • New 1:1 chat (openReport with newReportObject): after failureData is applied, the report has errorFields.createChat set, the optimistic CREATED action’s pendingAction is cleared, and getCreationReportErrors/getAllReportErrors return that error.
    • Dismiss/retry: with isOptimisticReport still true, closing the RBR routes through the delete‑and‑go‑to‑Concierge branch of clearCreateChatError (the failed chat is discarded, not kept).
    • Group chat (createGroupChat): on failure the group report gets errorFields.createChat and surfaces the RBR.
    • Success path: after successData is applied, both errorFields.createChat and pendingFields.createChat are cleared (no latched error).
    • Regression guard for threads: creating a new thread still writes errorFields.createChatThread and does not get the DM createChat error.

    What alternative solutions did you explore? (Optional)

    • Only add errorFields.createChat in openReport (what most existing proposals do). Necessary but not sufficient: for the reported simulate‑failing repro the app is already in offline mode, so SequentialQueue exits before any failureData is applied and the error never shows. That’s why the Part‑1 FailureTracking guard is required in addition.
    • Broaden the existing isNewThread guard to isCreatingNewReport and reuse a single createChat key for both chats and threads. Less duplication, but createChatThread is consumed directly at a different call site (src/pages/inbox/report/ReportActionItemParentAction.tsx), so collapsing the keys would change thread error rendering. The additive, scoped approach keeps both consumers intact.
    • Also merge isOptimisticReport: false / clear pendingFields.createChat on failure. Rejected — this breaks the dismiss/retry semantics described in Part 3(b): it would keep a report the server never created and prevent a clean “start over.”
    • Handle it in NewChatPage.selectOption() (or keep the modal open until OpenReport succeeds). Rejected — it covers only one entry point, duplicates request‑failure handling outside the action that owns the optimistic create‑chat state, and diverges from the established optimistic/OfflineWithFeedback pattern.
    • Close as WAI. If product decides that converting simulated failures into offline mode and silently queuing the chat is the intended offline‑first behavior, this is a no‑op. I don’t recommend it: the tester’s expectation (“chat creation should fail and an error should be shown”) is exactly what the existing thread/workspace‑chat paths already do, so the DM path is inconsistent rather than intentional.
  10. lorretheboy commented on Jul 10, 2026

    @lorretheboy
    Contributor

    🚫 Duplicated proposal withdrawn by 🤖 ProposalPolice.

  11. melvin-bot commented on Jul 10, 2026

    @melvin-bot

    Triggered auto assignment to Contributor-plus team member for initial proposal review - @dmkt9 (External)

  12. changed the title [-]No error is displayed when creating a chat with failing network request[/-] [+][$250] No error is displayed when creating a chat with failing network request[/+] on Jul 10, 2026
  13. melvin-bot commented on Jul 10, 2026

    @melvin-bot
  14. 68 remaining items

  15. melvin-bot commented on Aug 11, 2026

    @melvin-bot

    Payment Summary

    Resolving PRs:

    Upwork Job

    • ROLE: @nabi-ebrahimi paid $(AMOUNT) via Upwork (LINK)
    • ROLE: @dmkt9 paid $(AMOUNT) via Upwork (LINK)

    BugZero Checklist (@mallenexpensify)

    • I have confirmed assignees, roles, and Upwork contracts look correct
    • I have paid out Upwork contracts / manual NewDot requests
  16. mallenexpensify commented on Aug 13, 2026

    @mallenexpensify
    Contributor

    @deetergp two PRs were needed here. which do you think it most accurate for payment amount

    1. $250 cuz the amount of work was expected
    2. $375 cuz one was a followup (or the amount of work warrants an increase)
    3. $500 cuz PRs are separate and should be $250 each.

    @abbasifaizan70 @dmkt9 can you please accept the job below? Please reply here and tag me once you have. I can raise job price later, if needed.

    If you're not sent an offer in Upwork when you're assigned to an issue, please tag me. If an Upwork job exists, please submit a proposal.
    https://www.upwork.com/jobs/~022088003836253231780

  17. abbasifaizan70 commented on Aug 13, 2026

    @abbasifaizan70
    Contributor

    @mallenexpensify You again tagged me above wrongly.

  18. dmkt9 commented on Aug 14, 2026

    @dmkt9
    Contributor

    @mallenexpensify Thanks. I've accepted the offer

  19. nabi-ebrahimi commented on Aug 14, 2026

    @nabi-ebrahimi
    Contributor

    @mallenexpensify, Accepted the offer, i think it should be $375. thanks.

  20. mallenexpensify commented on Aug 18, 2026

    @mallenexpensify
    Contributor

    @MelvinBot two PRs were needed here. which do you think it most accurate for payment amount

    $250 cuz the amount of work was expected
    $375 cuz one was a followup (or the amount of work warrants an increase)
    $500 cuz PRs are separate and should be $250 each.

  21. MelvinBot commented on Aug 18, 2026

    @MelvinBot
    Contributor

    I'd go with $375 (option 2).

    Both PRs are by the same contributor (nabi-ebrahimi, reviewed by dmkt9), and the second was a genuine followup on the same flow rather than a separate bug:

    Why not the other two options:

    So it's more than the base scope but less than two full jobs — $375 is the fair middle. That matches what nabi-ebrahimi requested above too.

  22. mallenexpensify commented on Aug 18, 2026

    @mallenexpensify
    Contributor

    Payment Summary

    Contributor: @nabi-ebrahimi paid $375 via Upwork
    Contributor+: @dmkt9 paid $375 via Upwork

    ^ Test case created. Thx

  23. nabi-ebrahimi commented on Aug 19, 2026

    @nabi-ebrahimi
    Contributor

    @mallenexpensify, thanks, please update the summay, i got paid. not @abbasifaizan70.

  24. mallenexpensify commented on Aug 19, 2026

    @mallenexpensify
    Contributor

    Thx @nabi-ebrahimi , I blame GH for their shitty user recommendations. Apologies @abbasifaizan70 :/

    Image
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Labels

Awaiting PaymentAuto-added when associated PR is deployed to productionBugSomething is broken. Auto assigns a BugZero manager.DailyKSv2ExternalAdded to denote the issue can be worked on by a contributor

Type

No type

Projects

No projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions