diff --git a/lib/hooks/input-state-container-hooks.js b/lib/hooks/input-state-container-hooks.js
index 3f70e1d01..33ed2943d 100644
--- a/lib/hooks/input-state-container-hooks.js
+++ b/lib/hooks/input-state-container-hooks.js
@@ -1,409 +1,418 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import uuid from 'uuid';
 
 import {
   type ProcessHolders,
   useProcessBlobHolders,
 } from '../actions/holder-actions.js';
 import {
   useLegacySendMultimediaMessage,
   useSendMultimediaMessage,
   useSendTextMessage,
 } from '../actions/message-actions.js';
 import type { MediaMetadataReassignmentAction } from '../actions/upload-actions.js';
 import {
   useMediaMetadataReassignment,
   updateMultimediaMessageMediaActionType,
 } from '../actions/upload-actions.js';
 import {
   encryptedMediaBlobURI,
   encryptedVideoThumbnailBlobURI,
 } from '../media/media-utils.js';
 import { dmOperationSpecificationTypes } from '../shared/dm-ops/dm-op-utils.js';
 import { useSendComposableDMOperation } from '../shared/dm-ops/process-dm-ops.js';
 import type { BlobOperation } from '../types/holder-types.js';
 import type {
   EncryptedImage,
   EncryptedVideo,
   Media,
 } from '../types/media-types.js';
 import type {
   RawMultimediaMessageInfo,
   SendMessagePayload,
 } from '../types/message-types.js';
 import { getMediaMessageServerDBContentsFromMedia } from '../types/messages/media.js';
 import type { RawTextMessageInfo } from '../types/messages/text.js';
 import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
 import type { Dispatch } from '../types/redux-types.js';
 import {
   thickThreadTypes,
   threadTypeIsThick,
 } from '../types/thread-types-enum.js';
 import {
   blobHashFromBlobServiceURI,
   isBlobServiceURI,
 } from '../utils/blob-service.js';
+import { SendMessageError } from '../utils/errors.js';
 import { useSelector, useDispatch } from '../utils/redux-utils.js';
 
 type MediaIDUpdatePayload = { +id: string, +thumbnailID?: string };
 type MediaIDUpdates = { +[string]: MediaIDUpdatePayload };
 export type SendMultimediaMessagePayload = {
   +result: SendMessagePayload,
   +mediaIDUpdates?: MediaIDUpdates,
 };
 
 function useInputStateContainerSendTextMessage(): (
   messageInfo: RawTextMessageInfo,
   threadInfo: ThreadInfo,
   parentThreadInfo: ?ThreadInfo,
   sidebarCreation: boolean,
 ) => Promise<SendMessagePayload> {
   const sendTextMessage = useSendTextMessage();
   const sendComposableDMOperation = useSendComposableDMOperation();
 
   return React.useCallback(
     async (
       messageInfo: RawTextMessageInfo,
       threadInfo: ThreadInfo,
       parentThreadInfo: ?ThreadInfo,
       sidebarCreation: boolean,
     ) => {
       const { localID } = messageInfo;
       invariant(
         localID !== null && localID !== undefined,
         'localID should be set',
       );
       if (!threadTypeIsThick(threadInfo.type)) {
         const result = await sendTextMessage({
           threadID: messageInfo.threadID,
           localID,
           text: messageInfo.text,
           sidebarCreation,
         });
         return {
           localID,
           serverID: result.id,
           threadID: messageInfo.threadID,
           time: result.time,
         };
       }
 
       const messageID = uuid.v4();
       const time = Date.now();
 
       const recipients =
         threadInfo.type === thickThreadTypes.THICK_SIDEBAR && parentThreadInfo
           ? parentThreadInfo.members
           : threadInfo.members;
       const recipientsIDs = recipients.map(recipient => recipient.id);
 
       const result = await sendComposableDMOperation({
         type: dmOperationSpecificationTypes.OUTBOUND,
         op: {
           type: 'send_text_message',
           threadID: threadInfo.id,
           creatorID: messageInfo.creatorID,
           time,
           messageID,
           text: messageInfo.text,
         },
         // We need to use a different mechanism than `all_thread_members`
         // because when creating a thread, the thread might not yet
         // be in the store.
         recipients: {
           type: 'some_users',
           userIDs: recipientsIDs,
         },
         sendOnly: true,
         composableMessageID: localID,
       });
 
       if (result.result === 'failure' && result.failedMessageIDs.length > 0) {
-        const e: any = new Error('Failed to send message to all peers');
-        e.failedOutboundP2PMessageIDs = result.failedMessageIDs;
-        throw e;
+        const error = new SendMessageError(
+          'Failed to send message to all peers',
+          localID,
+          messageInfo.threadID,
+        );
+        error.failedOutboundP2PMessageIDs = result.failedMessageIDs;
+        throw error;
       }
       return {
         localID,
         serverID: messageID,
         threadID: messageInfo.threadID,
         time,
       };
     },
     [sendComposableDMOperation, sendTextMessage],
   );
 }
 
 function useInputStateContainerSendMultimediaMessage(): (
   messageInfo: RawMultimediaMessageInfo,
   sidebarCreation: boolean,
   isLegacy: boolean,
 ) => Promise<SendMultimediaMessagePayload> {
   const sendMultimediaMessage = useSendMultimediaMessage();
   const legacySendMultimediaMessage = useLegacySendMultimediaMessage();
   const sendComposableDMOperation = useSendComposableDMOperation();
   const threadInfos = useSelector(state => state.threadStore.threadInfos);
 
   const reassignThickThreadMedia = useMediaMetadataReassignment();
   const processHolders = useProcessBlobHolders();
   const dispatch = useDispatch();
 
   return React.useCallback(
     async (
       messageInfo: RawMultimediaMessageInfo,
       sidebarCreation: boolean,
       isLegacy: boolean,
     ) => {
       const { localID } = messageInfo;
       invariant(
         localID !== null && localID !== undefined,
         'localID should be set',
       );
 
       const threadInfo = threadInfos[messageInfo.threadID];
       const isThickThread = threadInfo && threadTypeIsThick(threadInfo.type);
 
       if (!isThickThread && isLegacy) {
         const { messageMedia, mediaIDUpdates } =
           await migrateMessageMediaToKeyserver(
             messageInfo,
             reassignThickThreadMedia,
             dispatch,
             processHolders,
           );
         const mediaIDs = [];
         for (const { id } of messageMedia) {
           mediaIDs.push(id);
         }
         const result = await legacySendMultimediaMessage({
           threadID: messageInfo.threadID,
           localID,
           mediaIDs,
           sidebarCreation,
         });
         return {
           result: {
             localID,
             serverID: result.id,
             threadID: messageInfo.threadID,
             time: result.time,
           },
           mediaIDUpdates,
         };
       }
 
       if (!isThickThread && !isLegacy) {
         const { messageMedia, mediaIDUpdates } =
           await migrateMessageMediaToKeyserver(
             messageInfo,
             reassignThickThreadMedia,
             dispatch,
             processHolders,
           );
         const mediaMessageContents =
           getMediaMessageServerDBContentsFromMedia(messageMedia);
         const result = await sendMultimediaMessage({
           threadID: messageInfo.threadID,
           localID,
           mediaMessageContents,
           sidebarCreation,
         });
         return {
           result: {
             localID,
             serverID: result.id,
             threadID: messageInfo.threadID,
             time: result.time,
           },
           mediaIDUpdates,
         };
       }
 
       const messageID = uuid.v4();
       const time = Date.now();
 
       const result = await sendComposableDMOperation({
         type: dmOperationSpecificationTypes.OUTBOUND,
         op: {
           type: 'send_multimedia_message',
           threadID: threadInfo.id,
           creatorID: messageInfo.creatorID,
           time: Date.now(),
           messageID,
           media: messageInfo.media,
         },
         recipients: {
           type: 'all_thread_members',
           threadID:
             threadInfo.type === thickThreadTypes.THICK_SIDEBAR &&
             threadInfo.parentThreadID
               ? threadInfo.parentThreadID
               : threadInfo.id,
         },
         sendOnly: true,
         composableMessageID: localID,
       });
 
       if (result.result === 'failure' && result.failedMessageIDs.length > 0) {
-        const e: any = new Error('Failed to send message to all peers');
-        e.failedOutboundP2PMessageIDs = result.failedMessageIDs;
-        throw e;
+        const error = new SendMessageError(
+          'Failed to send message to all peers',
+          localID,
+          messageInfo.threadID,
+        );
+        error.failedOutboundP2PMessageIDs = result.failedMessageIDs;
+        throw error;
       }
       return {
         result: {
           localID,
           serverID: messageID,
           threadID: messageInfo.threadID,
           time,
         },
       };
     },
     [
       dispatch,
       processHolders,
       legacySendMultimediaMessage,
       reassignThickThreadMedia,
       sendComposableDMOperation,
       sendMultimediaMessage,
       threadInfos,
     ],
   );
 }
 
 function mediaIDIsKeyserverID(mediaID: string): boolean {
   return mediaID.indexOf('|') !== -1;
 }
 
 async function migrateMessageMediaToKeyserver(
   messageInfo: RawMultimediaMessageInfo,
   reassignMediaMetadata: MediaMetadataReassignmentAction,
   dispatch: Dispatch,
   processHolders: ProcessHolders,
 ): Promise<{
   +messageMedia: $ReadOnlyArray<Media>,
   +mediaIDUpdates: MediaIDUpdates,
 }> {
   const messageMedia = [],
     holderActions: Array<BlobOperation> = [];
   let mediaIDUpdates: MediaIDUpdates = {};
 
   const processMediaChanges = (
     prevMediaID: string,
     changes: {
       ...MediaIDUpdatePayload,
       +blobsToRemoveHolder: $ReadOnlyArray<string>,
     },
   ) => {
     const { blobsToRemoveHolder, ...mediaUpdate } = changes;
     const newHolderActions = blobsToRemoveHolder.map(blobHash => ({
       type: 'remove_holder',
       blobHash,
     }));
     holderActions.push(...newHolderActions);
 
     mediaIDUpdates = { ...mediaIDUpdates, [prevMediaID]: mediaUpdate };
     dispatch({
       type: updateMultimediaMessageMediaActionType,
       payload: {
         messageID: messageInfo.localID,
         currentMediaID: prevMediaID,
         mediaUpdate,
       },
     });
   };
 
   const reassignmentPromises = messageInfo.media.map(async media => {
     if (
       mediaIDIsKeyserverID(media.id) ||
       (media.type !== 'encrypted_photo' && media.type !== 'encrypted_video')
     ) {
       messageMedia.push(media);
       return;
     }
 
     const mediaURI = encryptedMediaBlobURI(media);
     invariant(
       isBlobServiceURI(mediaURI),
       'thick thread media should be blob-hosted',
     );
 
     // This is only to determine server-side if media is photo or video.
     // We can mock mime type to represent one of them.
     const mimeType =
       media.type === 'encrypted_photo' ? 'image/jpeg' : 'video/mp4';
     const blobHash = blobHashFromBlobServiceURI(mediaURI);
     const mediaReassignmentPromise = reassignMediaMetadata({
       keyserverOrThreadID: messageInfo.threadID,
       mediaMetadataInput: {
         blobHash,
         mimeType,
         dimensions: media.dimensions,
         thumbHash: media.thumbHash,
         encryptionKey: media.encryptionKey,
         loop: media.loop,
       },
     });
 
     if (media.type !== 'encrypted_video') {
       const { id } = await mediaReassignmentPromise;
 
       const updatedMedia: EncryptedImage = { ...media, id };
       messageMedia.push(updatedMedia);
 
       const mediaChanges = { id, blobsToRemoveHolder: [blobHash] };
       processMediaChanges(media.id, mediaChanges);
 
       return;
     }
 
     const thumbnailMediaURI = encryptedVideoThumbnailBlobURI(media);
     invariant(
       isBlobServiceURI(thumbnailMediaURI),
       'thick thread media thumbnail should be blob-hosted',
     );
 
     const thumbnailBlobHash = blobHashFromBlobServiceURI(thumbnailMediaURI);
     const thumbnailReassignmentPromise = reassignMediaMetadata({
       keyserverOrThreadID: messageInfo.threadID,
       mediaMetadataInput: {
         blobHash: thumbnailBlobHash,
         mimeType: 'image/jpeg',
         dimensions: media.dimensions,
         thumbHash: media.thumbnailThumbHash,
         encryptionKey: media.thumbnailEncryptionKey,
         loop: false,
       },
     });
 
     const [{ id }, { id: thumbnailID }] = await Promise.all([
       mediaReassignmentPromise,
       thumbnailReassignmentPromise,
     ]);
 
     const updatedMedia: EncryptedVideo = { ...media, id, thumbnailID };
     messageMedia.push(updatedMedia);
 
     const mediaChanges = {
       id,
       thumbnailID,
       blobsToRemoveHolder: [blobHash, thumbnailBlobHash],
     };
     processMediaChanges(media.id, mediaChanges);
   });
 
   await Promise.all(reassignmentPromises);
   void processHolders(holderActions);
 
   return {
     messageMedia,
     mediaIDUpdates,
   };
 }
 
 export {
   useInputStateContainerSendTextMessage,
   useInputStateContainerSendMultimediaMessage,
 };
diff --git a/lib/types/redux-types.js b/lib/types/redux-types.js
index 0a6ff0c88..032c51907 100644
--- a/lib/types/redux-types.js
+++ b/lib/types/redux-types.js
@@ -1,1693 +1,1680 @@
 // @flow
 
 import type { PersistState } from 'redux-persist/es/types';
 
 import type {
   LogOutResult,
   KeyserverLogOutResult,
   LegacyLogInStartingPayload,
   LegacyLogInResult,
   LegacyRegisterResult,
   DefaultNotificationPayload,
   ClaimUsernameResponse,
   KeyserverAuthResult,
 } from './account-types.js';
 import type {
   ActivityUpdateSuccessPayload,
   QueueActivityUpdatesPayload,
   SetThreadUnreadStatusPayload,
 } from './activity-types.js';
 import type { AlertStore, RecordAlertActionPayload } from './alert-types.js';
 import type {
   AuxUserStore,
   SetAuxUserFIDsPayload,
   AddAuxUserFIDsPayload,
   RemovePeerUsersPayload,
   SetPeerDeviceListsPayload,
   SetMissingDeviceListsPayload,
 } from './aux-user-types.js';
 import type {
   UpdateUserAvatarRequest,
   UpdateUserAvatarResponse,
 } from './avatar-types.js';
 import type {
   CommunityStore,
   AddCommunityPayload,
   FetchCommunityInfosResponse,
   FetchAllCommunityInfosWithNamesResponse,
   CreateOrUpdateFarcasterChannelTagResponse,
   DeleteFarcasterChannelTagPayload,
 } from './community-types.js';
 import type { DBOpsStore } from './db-ops-types.js';
 import type {
   GetVersionActionPayload,
   LastCommunicatedPlatformDetails,
 } from './device-types.js';
 import type {
   ProcessDMOpsPayload,
   QueuedDMOperations,
   QueueDMOpsPayload,
   PruneDMOpsQueuePayload,
   ClearQueuedThreadDMOpsPayload,
   ClearQueuedMessageDMOpsPayload,
   ClearQueuedEntryDMOpsPayload,
   ClearQueuedMembershipDMOpsPayload,
 } from './dm-ops.js';
 import type { DraftStore } from './draft-types.js';
 import type { EnabledApps, SupportedApps } from './enabled-apps.js';
 import type {
   RawEntryInfo,
   EntryStore,
   SaveEntryPayload,
   CreateEntryPayload,
   DeleteEntryResult,
   RestoreEntryPayload,
   FetchEntryInfosResult,
   CalendarQueryUpdateResult,
   CalendarQueryUpdateStartingPayload,
   FetchRevisionsForEntryPayload,
 } from './entry-types.js';
 import type {
   CalendarFilter,
   CalendarThreadFilter,
   SetCalendarDeletedFilterPayload,
 } from './filter-types.js';
 import type { HolderStore, BlobHashAndHolder } from './holder-types.js';
 import type { IdentityAuthResult } from './identity-service-types';
 import type { IntegrityStore } from './integrity-types.js';
 import type {
   KeyserverStore,
   AddKeyserverPayload,
   RemoveKeyserverPayload,
 } from './keyserver-types.js';
 import type { LifecycleState } from './lifecycle-state-types.js';
 import type {
   FetchInviteLinksResponse,
   InviteLink,
   InviteLinksStore,
   InviteLinkVerificationResponse,
   DisableInviteLinkPayload,
 } from './link-types.js';
 import type { LoadingStatus, LoadingInfo } from './loading-types.js';
 import type { UpdateMultimediaMessageMediaPayload } from './media-types.js';
 import type { MessageReportCreationResult } from './message-report-types.js';
 import type {
   MessageStore,
   RawMultimediaMessageInfo,
   FetchMessageInfosPayload,
   SendMessagePayload,
   EditMessagePayload,
   SaveMessagesPayload,
   NewMessagesPayload,
   MessageStorePrunePayload,
   LocallyComposedMessageInfo,
   SimpleMessagesPayload,
   FetchPinnedMessagesResult,
   SearchMessagesResponse,
 } from './message-types.js';
 import type { RawReactionMessageInfo } from './messages/reaction.js';
 import type { RawTextMessageInfo } from './messages/text.js';
 import type { BaseNavInfo, WebNavInfo } from './nav-types.js';
 import type { GetOlmSessionInitializationDataResponse } from './olm-session-types.js';
 import {
   type ForcePolicyAcknowledgmentPayload,
   type PolicyAcknowledgmentPayload,
   type UserPolicies,
 } from './policy-types.js';
 import type { RelationshipErrors } from './relationship-types.js';
 import type {
   EnabledReports,
   ClearDeliveredReportsPayload,
   QueueReportsPayload,
   ReportStore,
 } from './report-types.js';
 import type { ProcessServerRequestAction } from './request-types.js';
 import type {
   UserSearchResult,
   ExactUserSearchResult,
 } from './search-types.js';
 import type { SetSessionPayload } from './session-types.js';
 import type {
   ConnectionIssue,
   StateSyncFullActionPayload,
   StateSyncIncrementalActionPayload,
   SetActiveSessionRecoveryPayload,
   ClientStateSyncSocketResult,
 } from './socket-types.js';
 import { type ClientStore } from './store-ops-types.js';
 import type { SubscriptionUpdateResult } from './subscription-types.js';
 import type {
   SyncedMetadataStore,
   SetSyncedMetadataEntryPayload,
   ClearSyncedMetadataEntryPayload,
 } from './synced-metadata-types.js';
 import type { GlobalThemeInfo } from './theme-types.js';
 import type { ThreadActivityStore } from './thread-activity-types.js';
 import type {
   ThreadStore,
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   NewThreadResult,
   ThreadJoinPayload,
   ToggleMessagePinResult,
   LegacyThreadStore,
   RoleModificationPayload,
   RoleDeletionPayload,
 } from './thread-types.js';
 import type { TunnelbrokerDeviceToken } from './tunnelbroker-device-token-types.js';
 import type { ClientUpdatesResultWithUserInfos } from './update-types.js';
 import type {
   CurrentUserInfo,
   UserInfos,
   UserStore,
   UserInfo,
 } from './user-types.js';
 import type {
   SetDeviceTokenActionPayload,
   SetDeviceTokenStartedPayload,
 } from '../actions/device-actions.js';
 import type {
   ProcessHoldersStartedPayload,
   ProcessHoldersFailedPayload,
   ProcessHoldersFinishedPayload,
 } from '../actions/holder-actions.js';
 import type {
   UpdateConnectionStatusPayload,
   SetLateResponsePayload,
   UpdateKeyserverReachabilityPayload,
 } from '../keyserver-conn/keyserver-conn-types.js';
+import type { SendMessageError } from '../utils/errors.js';
 
 export type BaseAppState<NavInfo: BaseNavInfo = BaseNavInfo> = {
   +navInfo: NavInfo,
   +currentUserInfo: ?CurrentUserInfo,
   +draftStore: DraftStore,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userStore: UserStore,
   +messageStore: MessageStore,
   +loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
   +calendarFilters: $ReadOnlyArray<CalendarFilter>,
   +alertStore: AlertStore,
   +watchedThreadIDs: $ReadOnlyArray<string>,
   +lifecycleState: LifecycleState,
   +enabledApps: EnabledApps,
   +reportStore: ReportStore,
   +dataLoaded: boolean,
   +userPolicies: UserPolicies,
   +commServicesAccessToken: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverStore: KeyserverStore,
   +threadActivityStore: ThreadActivityStore,
   +integrityStore: IntegrityStore,
   +globalThemeInfo: GlobalThemeInfo,
   +customServer: ?string,
   +communityStore: CommunityStore,
   +dbOpsStore: DBOpsStore,
   +syncedMetadataStore: SyncedMetadataStore,
   +auxUserStore: AuxUserStore,
   +tunnelbrokerDeviceToken: TunnelbrokerDeviceToken,
   +_persist: ?PersistState,
   +queuedDMOperations: QueuedDMOperations,
   +holderStore: HolderStore,
   +initialStateLoaded: boolean,
   ...
 };
 
 export type NativeAppState = BaseAppState<>;
 export type WebAppState = BaseAppState<> & {
   +pushApiPublicKey: ?string,
   ...
 };
 export type AppState = NativeAppState | WebAppState;
 
 export type ClientWebInitialReduxStateResponse = {
   +navInfo: WebNavInfo,
   +currentUserInfo: CurrentUserInfo,
   +entryStore: EntryStore,
   +threadStore: ThreadStore,
   +userInfos: UserInfos,
   +messageStore: MessageStore,
   +pushApiPublicKey: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverInfo: WebInitialKeyserverInfo,
 };
 export type ServerWebInitialReduxStateResponse = {
   +navInfo: WebNavInfo,
   +currentUserInfo: CurrentUserInfo,
   +entryStore: EntryStore,
   +threadStore: LegacyThreadStore,
   +userInfos: UserInfos,
   +messageStore: MessageStore,
   +pushApiPublicKey: ?string,
   +inviteLinksStore: InviteLinksStore,
   +keyserverInfo: WebInitialKeyserverInfo,
 };
 export type WebInitialKeyserverInfo = {
   +sessionID: ?string,
   +updatesCurrentAsOf: number,
 };
 
 export type BaseAction = $ReadOnly<{
   +dispatchMetadata?: DispatchMetadata,
   ...
     | {
         +type: '@@redux/INIT',
         +payload?: void,
       }
     | {
         +type: 'FETCH_ENTRIES_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_ENTRIES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_ENTRIES_SUCCESS',
         +payload: FetchEntryInfosResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LOG_OUT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LOG_OUT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LOG_OUT_SUCCESS',
         +payload: LogOutResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CLAIM_USERNAME_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CLAIM_USERNAME_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CLAIM_USERNAME_SUCCESS',
         +payload: ClaimUsernameResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_KEYSERVER_ACCOUNT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_KEYSERVER_ACCOUNT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_KEYSERVER_ACCOUNT_SUCCESS',
         +payload: KeyserverLogOutResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_ACCOUNT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_ACCOUNT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_ACCOUNT_SUCCESS',
         +payload: LogOutResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_LOCAL_ENTRY',
         +payload: RawEntryInfo,
       }
     | {
         +type: 'CREATE_ENTRY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_ENTRY_SUCCESS',
         +payload: CreateEntryPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SAVE_ENTRY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SAVE_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SAVE_ENTRY_SUCCESS',
         +payload: SaveEntryPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CONCURRENT_MODIFICATION_RESET',
         +payload: {
           +id: string,
           +dbText: string,
         },
       }
     | {
         +type: 'DELETE_ENTRY_STARTED',
         +loadingInfo: LoadingInfo,
         +payload: {
           +localID: ?string,
           +serverID: ?string,
         },
       }
     | {
         +type: 'DELETE_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_ENTRY_SUCCESS',
         +payload: ?DeleteEntryResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_LOG_IN_STARTED',
         +loadingInfo: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'IDENTITY_LOG_IN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_LOG_IN_SUCCESS',
         +payload: IdentityAuthResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'KEYSERVER_AUTH_STARTED',
         +loadingInfo: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'KEYSERVER_AUTH_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'KEYSERVER_AUTH_SUCCESS',
         +payload: KeyserverAuthResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_LOG_IN_STARTED',
         +loadingInfo: LoadingInfo,
         +payload: LegacyLogInStartingPayload,
       }
     | {
         +type: 'LEGACY_LOG_IN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_LOG_IN_SUCCESS',
         +payload: LegacyLogInResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_KEYSERVER_REGISTER_STARTED',
         +loadingInfo: LoadingInfo,
         +payload: LegacyLogInStartingPayload,
       }
     | {
         +type: 'LEGACY_KEYSERVER_REGISTER_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_KEYSERVER_REGISTER_SUCCESS',
         +payload: LegacyRegisterResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_REGISTER_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_REGISTER_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_REGISTER_SUCCESS',
         +payload: IdentityAuthResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_GENERATE_NONCE_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_GENERATE_NONCE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'IDENTITY_GENERATE_NONCE_SUCCESS',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_KEYSERVER_USER_PASSWORD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_KEYSERVER_USER_PASSWORD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_KEYSERVER_USER_PASSWORD_SUCCESS',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_IDENTITY_USER_PASSWORD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_IDENTITY_USER_PASSWORD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_IDENTITY_USER_PASSWORD_SUCCESS',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_SETTINGS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_SETTINGS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_SETTINGS_SUCCESS',
         +payload: ChangeThreadSettingsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_THREAD_SUCCESS',
         +payload: LeaveThreadPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'NEW_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'NEW_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'NEW_THREAD_SUCCESS',
         +payload: NewThreadResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REMOVE_USERS_FROM_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REMOVE_USERS_FROM_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
         +payload: ChangeThreadSettingsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
         +payload: ChangeThreadSettingsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_REVISIONS_FOR_ENTRY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_REVISIONS_FOR_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_REVISIONS_FOR_ENTRY_SUCCESS',
         +payload: FetchRevisionsForEntryPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'RESTORE_ENTRY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'RESTORE_ENTRY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'RESTORE_ENTRY_SUCCESS',
         +payload: RestoreEntryPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'JOIN_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'JOIN_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'JOIN_THREAD_SUCCESS',
         +payload: ThreadJoinPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEAVE_THREAD_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEAVE_THREAD_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEAVE_THREAD_SUCCESS',
         +payload: LeaveThreadPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_NEW_SESSION',
         +payload: SetSessionPayload,
       }
     | {
         +type: 'persist/REHYDRATE',
         +payload: ?BaseAppState<>,
       }
     | {
         +type: 'FETCH_MESSAGES_BEFORE_CURSOR_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MESSAGES_BEFORE_CURSOR_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MESSAGES_BEFORE_CURSOR_SUCCESS',
         +payload: FetchMessageInfosPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MOST_RECENT_MESSAGES_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MOST_RECENT_MESSAGES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_MOST_RECENT_MESSAGES_SUCCESS',
         +payload: FetchMessageInfosPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_SUCCESS',
         +payload: SimpleMessagesPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_TEXT_MESSAGE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload: RawTextMessageInfo,
       }
     | {
         +type: 'SEND_TEXT_MESSAGE_FAILED',
         +error: true,
-        +payload: Error & {
-          +localID: string,
-          +threadID: string,
-          +failedOutboundP2PMessageIDs?: $ReadOnlyArray<string>,
-        },
+        +payload: SendMessageError,
         +loadingInfo?: LoadingInfo,
       }
     | {
         +type: 'SEND_TEXT_MESSAGE_SUCCESS',
         +payload: SendMessagePayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_MULTIMEDIA_MESSAGE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload: RawMultimediaMessageInfo,
       }
     | {
         +type: 'SEND_MULTIMEDIA_MESSAGE_FAILED',
         +error: true,
-        +payload: Error & {
-          +localID: string,
-          +threadID: string,
-          +failedOutboundP2PMessageIDs?: $ReadOnlyArray<string>,
-        },
+        +payload: SendMessageError,
         +loadingInfo?: LoadingInfo,
       }
     | {
         +type: 'SEND_MULTIMEDIA_MESSAGE_SUCCESS',
         +payload: SendMessagePayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REACTION_MESSAGE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload: RawReactionMessageInfo,
       }
     | {
         +type: 'SEND_REACTION_MESSAGE_FAILED',
         +error: true,
-        +payload: Error & {
-          +localID: string,
-          +threadID: string,
-          +targetMessageID: string,
-          +reaction: string,
-          +action: string,
-        },
+        +payload: SendMessageError,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REACTION_MESSAGE_SUCCESS',
         +payload: SendMessagePayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEARCH_USERS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEARCH_USERS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEARCH_USERS_SUCCESS',
         +payload: UserSearchResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'EXACT_SEARCH_USER_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'EXACT_SEARCH_USER_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'EXACT_SEARCH_USER_SUCCESS',
         +payload: ExactUserSearchResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_DRAFT',
         +payload: {
           +key: string,
           +text: string,
         },
       }
     | {
         +type: 'MOVE_DRAFT',
         +payload: {
           +oldKey: string,
           +newKey: string,
         },
       }
     | {
         +type: 'SET_CLIENT_DB_STORE',
         +payload: ClientStore,
       }
     | {
         +type: 'UPDATE_ACTIVITY_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_ACTIVITY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_ACTIVITY_SUCCESS',
         +payload: ActivityUpdateSuccessPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_DEVICE_TOKEN_STARTED',
         +payload: SetDeviceTokenStartedPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_DEVICE_TOKEN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_DEVICE_TOKEN_SUCCESS',
         +payload: SetDeviceTokenActionPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORT_SUCCESS',
         +payload?: ClearDeliveredReportsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORTS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORTS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_REPORTS_SUCCESS',
         +payload?: ClearDeliveredReportsPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'QUEUE_REPORTS',
         +payload: QueueReportsPayload,
       }
     | {
         +type: 'SET_URL_PREFIX',
         +payload: string,
       }
     | {
         +type: 'SAVE_MESSAGES',
         +payload: SaveMessagesPayload,
       }
     | {
         +type: 'UPDATE_CALENDAR_THREAD_FILTER',
         +payload: CalendarThreadFilter,
       }
     | {
         +type: 'CLEAR_CALENDAR_THREAD_FILTER',
         +payload?: void,
       }
     | {
         +type: 'SET_CALENDAR_DELETED_FILTER',
         +payload: SetCalendarDeletedFilterPayload,
       }
     | {
         +type: 'UPDATE_SUBSCRIPTION_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_SUBSCRIPTION_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_SUBSCRIPTION_SUCCESS',
         +payload: SubscriptionUpdateResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_CALENDAR_QUERY_STARTED',
         +loadingInfo: LoadingInfo,
         +payload?: CalendarQueryUpdateStartingPayload,
       }
     | {
         +type: 'UPDATE_CALENDAR_QUERY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_CALENDAR_QUERY_SUCCESS',
         +payload: CalendarQueryUpdateResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FULL_STATE_SYNC',
         +payload: StateSyncFullActionPayload,
       }
     | {
         +type: 'INCREMENTAL_STATE_SYNC',
         +payload: StateSyncIncrementalActionPayload,
       }
     | ProcessServerRequestAction
     | {
         +type: 'UPDATE_CONNECTION_STATUS',
         +payload: UpdateConnectionStatusPayload,
       }
     | {
         +type: 'QUEUE_ACTIVITY_UPDATES',
         +payload: QueueActivityUpdatesPayload,
       }
     | {
         +type: 'UNSUPERVISED_BACKGROUND',
         +payload: { +keyserverID: string },
       }
     | {
         +type: 'UPDATE_LIFECYCLE_STATE',
         +payload: LifecycleState,
       }
     | {
         +type: 'ENABLE_APP',
         +payload: SupportedApps,
       }
     | {
         +type: 'DISABLE_APP',
         +payload: SupportedApps,
       }
     | {
         +type: 'UPDATE_REPORTS_ENABLED',
         +payload: Partial<EnabledReports>,
       }
     | {
         +type: 'PROCESS_UPDATES',
         +payload: ClientUpdatesResultWithUserInfos,
       }
     | {
         +type: 'PROCESS_MESSAGES',
         +payload: NewMessagesPayload,
       }
     | {
         +type: 'MESSAGE_STORE_PRUNE',
         +payload: MessageStorePrunePayload,
       }
     | {
         +type: 'SET_LATE_RESPONSE',
         +payload: SetLateResponsePayload,
       }
     | {
         +type: 'UPDATE_KEYSERVER_REACHABILITY',
         +payload: UpdateKeyserverReachabilityPayload,
       }
     | {
         +type: 'REQUEST_ACCESS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REQUEST_ACCESS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'REQUEST_ACCESS_SUCCESS',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
         +payload: UpdateMultimediaMessageMediaPayload,
       }
     | {
         +type: 'CREATE_LOCAL_MESSAGE',
         +payload: LocallyComposedMessageInfo,
       }
     | {
         +type: 'UPDATE_RELATIONSHIPS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_RELATIONSHIPS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_RELATIONSHIPS_SUCCESS',
         +payload: RelationshipErrors,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_THREAD_UNREAD_STATUS_STARTED',
         +payload: {
           +threadID: string,
           +unread: boolean,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_THREAD_UNREAD_STATUS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_THREAD_UNREAD_STATUS_SUCCESS',
         +payload: SetThreadUnreadStatusPayload,
       }
     | {
         +type: 'SET_USER_SETTINGS_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_USER_SETTINGS_SUCCESS',
         +payload: DefaultNotificationPayload,
       }
     | {
         +type: 'SET_USER_SETTINGS_FAILED',
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_MESSAGE_REPORT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_MESSAGE_REPORT_SUCCESS',
         +payload: MessageReportCreationResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_MESSAGE_REPORT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FORCE_POLICY_ACKNOWLEDGMENT',
         +payload: ForcePolicyAcknowledgmentPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'POLICY_ACKNOWLEDGMENT_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'POLICY_ACKNOWLEDGMENT_SUCCESS',
         +payload: PolicyAcknowledgmentPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'POLICY_ACKNOWLEDGMENT_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_SIWE_NONCE_STARTED',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_SIWE_NONCE_SUCCESS',
         +payload?: void,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_SIWE_NONCE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_SIWE_AUTH_STARTED',
         +payload: LegacyLogInStartingPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_SIWE_AUTH_SUCCESS',
         +payload: LegacyLogInResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'LEGACY_SIWE_AUTH_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'RECORD_ALERT',
         +payload: RecordAlertActionPayload,
       }
     | {
         +type: 'UPDATE_USER_AVATAR_STARTED',
         +payload: UpdateUserAvatarRequest,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_USER_AVATAR_SUCCESS',
         +payload: UpdateUserAvatarResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_USER_AVATAR_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_EDIT_MESSAGE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'SEND_EDIT_MESSAGE_SUCCESS',
         +payload: EditMessagePayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEND_EDIT_MESSAGE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'TOGGLE_MESSAGE_PIN_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'TOGGLE_MESSAGE_PIN_SUCCESS',
         +payload: ToggleMessagePinResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'TOGGLE_MESSAGE_PIN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PINNED_MESSAGES_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FETCH_PINNED_MESSAGES_SUCCESS',
         +payload: FetchPinnedMessagesResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PINNED_MESSAGES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'VERIFY_INVITE_LINK_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'VERIFY_INVITE_LINK_SUCCESS',
         +payload: InviteLinkVerificationResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'VERIFY_INVITE_LINK_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PRIMARY_INVITE_LINKS_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FETCH_PRIMARY_INVITE_LINKS_SUCCESS',
         +payload: FetchInviteLinksResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PRIMARY_INVITE_LINKS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_CALENDAR_COMMUNITY_FILTER',
         +payload: string,
       }
     | {
         +type: 'CLEAR_CALENDAR_COMMUNITY_FILTER',
         +payload: void,
       }
     | {
         +type: 'UPDATE_CHAT_COMMUNITY_FILTER',
         +payload: string,
       }
     | {
         +type: 'CLEAR_CHAT_COMMUNITY_FILTER',
         +payload: void,
       }
     | {
         +type: 'SEARCH_MESSAGES_STARTED',
         +payload: void,
         +loadingInfo?: LoadingInfo,
       }
     | {
         +type: 'SEARCH_MESSAGES_SUCCESS',
         +payload: SearchMessagesResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SEARCH_MESSAGES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_SUCCESS',
         +payload: InviteLink,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_OR_UPDATE_PUBLIC_LINK_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DISABLE_INVITE_LINK_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'DISABLE_INVITE_LINK_SUCCESS',
         +payload: DisableInviteLinkPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DISABLE_INVITE_LINK_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_SUCCESS',
         +payload: GetOlmSessionInitializationDataResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_OLM_SESSION_INITIALIZATION_DATA_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_DATA_LOADED',
         +payload: {
           +dataLoaded: boolean,
         },
       }
     | {
         +type: 'GET_VERSION_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'GET_VERSION_SUCCESS',
         +payload: GetVersionActionPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'GET_VERSION_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_LAST_COMMUNICATED_PLATFORM_DETAILS',
         +payload: LastCommunicatedPlatformDetails,
       }
     | { +type: 'RESET_USER_STATE', +payload?: void }
     | {
         +type: 'MODIFY_COMMUNITY_ROLE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'MODIFY_COMMUNITY_ROLE_SUCCESS',
         +payload: RoleModificationPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'MODIFY_COMMUNITY_ROLE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_COMMUNITY_ROLE_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'DELETE_COMMUNITY_ROLE_SUCCESS',
         +payload: RoleDeletionPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_COMMUNITY_ROLE_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'UPDATE_THREAD_LAST_NAVIGATED',
         +payload: { +threadID: string, +time: number },
       }
     | {
         +type: 'UPDATE_INTEGRITY_STORE',
         +payload: {
           +threadIDsToHash?: $ReadOnlyArray<string>,
           +threadHashingStatus?: 'starting' | 'running' | 'completed',
         },
       }
     | {
         +type: 'UPDATE_THEME_INFO',
         +payload: Partial<GlobalThemeInfo>,
       }
     | {
         +type: 'ADD_KEYSERVER',
         +payload: AddKeyserverPayload,
       }
     | {
         +type: 'REMOVE_KEYSERVER',
         +payload: RemoveKeyserverPayload,
       }
     | {
         +type: 'SET_CUSTOM_SERVER',
         +payload: string,
       }
     | {
         +type: 'SET_CONNECTION_ISSUE',
         +payload: { +connectionIssue: ?ConnectionIssue, +keyserverID: string },
       }
     | {
         +type: 'ADD_COMMUNITY',
         +payload: AddCommunityPayload,
       }
     | {
         +type: 'SET_SYNCED_METADATA_ENTRY',
         +payload: SetSyncedMetadataEntryPayload,
       }
     | {
         +type: 'CLEAR_SYNCED_METADATA_ENTRY',
         +payload: ClearSyncedMetadataEntryPayload,
       }
     | {
         +type: 'SET_ACTIVE_SESSION_RECOVERY',
         +payload: SetActiveSessionRecoveryPayload,
       }
     | {
         +type: 'SET_AUX_USER_FIDS',
         +payload: SetAuxUserFIDsPayload,
       }
     | {
         +type: 'ADD_AUX_USER_FIDS',
         +payload: AddAuxUserFIDsPayload,
       }
     | {
         +type: 'CLEAR_AUX_USER_FIDS',
         +payload?: void,
       }
     | {
         +type: 'REMOVE_PEER_USERS',
         +payload: RemovePeerUsersPayload,
       }
     | {
         +type: 'SET_PEER_DEVICE_LISTS',
         +payload: SetPeerDeviceListsPayload,
       }
     | {
         +type: 'OPS_PROCESSING_FINISHED_ACTION_TYPE',
         +payload?: void,
       }
     | {
         +type: 'FETCH_COMMUNITY_INFOS_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FETCH_COMMUNITY_INFOS_SUCCESS',
         +payload: FetchCommunityInfosResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_COMMUNITY_INFOS_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_ALL_COMMUNITY_INFOS_WITH_NAMES_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FETCH_ALL_COMMUNITY_INFOS_WITH_NAMES_SUCCESS',
         +payload: FetchAllCommunityInfosWithNamesResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_ALL_COMMUNITY_INFOS_WITH_NAMES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_SUCCESS',
         +payload: CreateOrUpdateFarcasterChannelTagResponse,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_FARCASTER_CHANNEL_TAG_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'DELETE_FARCASTER_CHANNEL_TAG_SUCCESS',
         +payload: DeleteFarcasterChannelTagPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'DELETE_FARCASTER_CHANNEL_TAG_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'PROCESS_NEW_USER_IDS',
         +payload: {
           +userIDs: $ReadOnlyArray<string>,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FIND_USER_IDENTITIES_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FIND_USER_IDENTITIES_SUCCESS',
         +payload: {
           +userInfos: $ReadOnlyArray<UserInfo>,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FIND_USER_IDENTITIES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'VERSION_SUPPORTED_BY_IDENTITY_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'VERSION_SUPPORTED_BY_IDENTITY_SUCCESS',
         +payload: {
           +supported: boolean,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'VERSION_SUPPORTED_BY_IDENTITY_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PENDING_UPDATES_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'FETCH_PENDING_UPDATES_SUCCESS',
         +payload: ClientStateSyncSocketResult,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'FETCH_PENDING_UPDATES_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_TB_DEVICE_TOKEN_STARTED',
         +loadingInfo?: LoadingInfo,
         +payload?: void,
       }
     | {
         +type: 'SET_TB_DEVICE_TOKEN_SUCCESS',
         +payload: {
           +deviceToken: string,
         },
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_TB_DEVICE_TOKEN_FAILED',
         +error: true,
         +payload: Error,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'PROCESS_DM_OPS',
         +payload: ProcessDMOpsPayload,
       }
     | {
         +type: 'INVALIDATE_TUNNELBROKER_DEVICE_TOKEN',
         +payload: {
           +deviceToken: string,
         },
       }
     | { +type: 'QUEUE_DM_OPS', +payload: QueueDMOpsPayload }
     | { +type: 'PRUNE_DM_OPS_QUEUE', +payload: PruneDMOpsQueuePayload }
     | {
         +type: 'CLEAR_QUEUED_THREAD_DM_OPS',
         +payload: ClearQueuedThreadDMOpsPayload,
       }
     | {
         +type: 'CLEAR_QUEUED_MESSAGE_DM_OPS',
         +payload: ClearQueuedMessageDMOpsPayload,
       }
     | {
         +type: 'CLEAR_QUEUED_ENTRY_DM_OPS',
         +payload: ClearQueuedEntryDMOpsPayload,
       }
     | {
         +type: 'CLEAR_QUEUED_MEMBERSHIP_DM_OPS',
         +payload: ClearQueuedMembershipDMOpsPayload,
       }
     | {
         +type: 'STORE_ESTABLISHED_HOLDER',
         +payload: BlobHashAndHolder,
       }
     | {
         +type: 'PROCESS_HOLDERS_STARTED',
         +payload: ProcessHoldersStartedPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'PROCESS_HOLDERS_FAILED',
         +error: true,
         +payload: Error & ProcessHoldersFailedPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'PROCESS_HOLDERS_SUCCESS',
         +payload: ProcessHoldersFinishedPayload,
         +loadingInfo: LoadingInfo,
       }
     | {
         +type: 'SET_MISSING_DEVICE_LISTS',
         +payload: SetMissingDeviceListsPayload,
       },
 }>;
 
 export type ActionPayload = ?(Object | Array<*> | $ReadOnlyArray<*> | string);
 export type DispatchSource = 'tunnelbroker' | 'tab-sync';
 // Data added when dispatching action as a result of message received
 // from other peer. It is used to send processing confirmation.
 export type InboundActionMetadata = {
   +messageID: string,
   +senderDeviceID: string,
 };
 // Data added when dispatching action triggered locally, used to resolve
 // promise associated with sending messages and track failed messages.
 export type OutboundActionMetadata = {
   +dmOpID: string,
 };
 export type DispatchMetadata = InboundActionMetadata | OutboundActionMetadata;
 export type SuperAction = {
   +type: string,
   +payload?: ActionPayload,
   +loadingInfo?: LoadingInfo,
   +error?: boolean,
   +dispatchSource?: DispatchSource,
   +dispatchMetadata?: DispatchMetadata,
 };
 type ThunkedAction = (dispatch: Dispatch) => void;
 export type PromisedAction = (dispatch: Dispatch) => Promise<void>;
 export type Dispatch = ((promisedAction: PromisedAction) => Promise<void>) &
   ((thunkedAction: ThunkedAction) => void) &
   ((action: SuperAction) => boolean);
 
 // This is lifted from redux-persist/lib/constants.js
 // I don't want to add redux-persist to the web/server bundles...
 // import { REHYDRATE } from 'redux-persist';
 export const rehydrateActionType = 'persist/REHYDRATE';
diff --git a/lib/utils/errors.js b/lib/utils/errors.js
index ab3b95d6e..13c780547 100644
--- a/lib/utils/errors.js
+++ b/lib/utils/errors.js
@@ -1,81 +1,87 @@
 // @flow
 
-import copyError from 'utils-copy-error';
-
 import type { PlatformDetails } from '../types/device-types.js';
 import type { ServerSocketMessageType } from '../types/socket-types.js';
 
 class ExtendableError extends Error {
   constructor(message: string) {
     super(message);
     this.name = this.constructor.name;
     this.message = message;
     if (typeof Error.captureStackTrace === 'function') {
       Error.captureStackTrace(this, this.constructor);
     } else {
       this.stack = new Error(message).stack;
     }
   }
 }
 
 class ServerError extends ExtendableError {
   // When specified on server side, will get passed down to client
   // Only used in updateEntry and deleteEntry currently
   payload: ?Object;
   // Used for client_version_unsupported on server-side only
   platformDetails: ?PlatformDetails;
   // Used for input validators on server-side only
   sanitizedInput: mixed;
 
   constructor(error: string, payload?: ?Object) {
     super(error);
     this.payload = payload;
   }
 }
 
 class FetchTimeout extends ExtendableError {
   url: string;
 
   constructor(error: string, url: string) {
     super(error);
     this.url = url;
   }
 }
 
 class SocketOffline extends ExtendableError {}
 
 class SocketTimeout extends ExtendableError {
   expectedResponseType: ServerSocketMessageType;
   constructor(expectedType: ServerSocketMessageType) {
     super(`socket timed out waiting for response type ${expectedType}`);
     this.expectedResponseType = expectedType;
   }
 }
 
+class SendMessageError extends ExtendableError {
+  localID: string;
+  threadID: string;
+  failedOutboundP2PMessageIDs: ?$ReadOnlyArray<string>;
+
+  constructor(error: string, localID: string, threadID: string) {
+    super(error);
+    this.localID = localID;
+    this.threadID = threadID;
+  }
+}
+
 function getMessageForException(e: mixed): ?string {
   if (typeof e === 'string') {
     return e;
   } else if (
     e &&
     typeof e === 'object' &&
     e.message &&
     typeof e.message === 'string'
   ) {
     return e.message;
   }
   return undefined;
 }
 
-function cloneError<E>(e: E): E {
-  return copyError(e);
-}
-
 export {
   ExtendableError,
   ServerError,
   FetchTimeout,
   getMessageForException,
-  cloneError,
   SocketOffline,
   SocketTimeout,
+  SendMessageError,
 };
diff --git a/native/chat/reaction-message-utils.js b/native/chat/reaction-message-utils.js
index 5e554c88a..dff3613ac 100644
--- a/native/chat/reaction-message-utils.js
+++ b/native/chat/reaction-message-utils.js
@@ -1,252 +1,253 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import uuid from 'uuid';
 
 import {
   useSendReactionMessage,
   sendReactionMessageActionTypes,
 } from 'lib/actions/message-actions.js';
 import type { ReactionInfo } from 'lib/selectors/chat-selectors.js';
 import {
   dmOperationSpecificationTypes,
   type OutboundDMOperationSpecification,
 } from 'lib/shared/dm-ops/dm-op-utils.js';
 import { useProcessAndSendDMOperation } from 'lib/shared/dm-ops/process-dm-ops.js';
 import { getNextLocalID } from 'lib/shared/message-utils.js';
 import type { DMSendReactionMessageOperation } from 'lib/types/dm-ops.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import type { RawReactionMessageInfo } from 'lib/types/messages/reaction.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types';
 import {
   thickThreadTypes,
   threadTypeIsThick,
 } from 'lib/types/thread-types-enum.js';
-import { cloneError } from 'lib/utils/errors.js';
+import { SendMessageError, getMessageForException } from 'lib/utils/errors.js';
 import { useDispatchActionPromise } from 'lib/utils/redux-promise-utils.js';
 
 import { useSelector } from '../redux/redux-utils.js';
 import type {
   LayoutCoordinates,
   VerticalBounds,
 } from '../types/layout-types.js';
 import Alert from '../utils/alert.js';
 
 function useSendReaction(
   messageID: ?string,
   threadInfo: ThreadInfo,
   reactions: ReactionInfo,
 ): (reaction: string) => mixed {
   const viewerID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
 
   const callSendReactionMessage = useSendReactionMessage();
   const dispatchActionPromise = useDispatchActionPromise();
   const processAndSendDMOperation = useProcessAndSendDMOperation();
 
   return React.useCallback(
     reaction => {
       if (!messageID) {
         return;
       }
 
       const localID = getNextLocalID();
 
       invariant(viewerID, 'viewerID should be set');
 
       const viewerReacted = reactions[reaction]
         ? reactions[reaction].viewerReacted
         : false;
       const action = viewerReacted ? 'remove_reaction' : 'add_reaction';
 
       const threadID = threadInfo.id;
 
       if (threadTypeIsThick(threadInfo.type)) {
         const op: DMSendReactionMessageOperation = {
           type: 'send_reaction_message',
           threadID,
           creatorID: viewerID,
           time: Date.now(),
           messageID: uuid.v4(),
           targetMessageID: messageID,
           reaction,
           action,
         };
         const opSpecification: OutboundDMOperationSpecification = {
           type: dmOperationSpecificationTypes.OUTBOUND,
           op,
           recipients: {
             type: 'all_thread_members',
             threadID:
               threadInfo.type === thickThreadTypes.THICK_SIDEBAR &&
               threadInfo.parentThreadID
                 ? threadInfo.parentThreadID
                 : threadInfo.id,
           },
         };
         void processAndSendDMOperation(opSpecification);
         return;
       }
 
       const reactionMessagePromise = (async () => {
         try {
           const result = await callSendReactionMessage({
             threadID,
             localID,
             targetMessageID: messageID,
             reaction,
             action,
           });
           return {
             localID,
             serverID: result.id,
             threadID,
             time: result.time,
           };
         } catch (e) {
           Alert.alert(
             'Couldn’t send the reaction',
             'Please try again later',
             [{ text: 'OK' }],
             {
               cancelable: true,
             },
           );
-
-          const copy = cloneError(e);
-          copy.localID = localID;
-          copy.threadID = threadID;
-          throw copy;
+          const exceptionMessage = getMessageForException(e) ?? '';
+          throw new SendMessageError(
+            `Exception while sending reaction: ${exceptionMessage}`,
+            localID,
+            threadID,
+          );
         }
       })();
 
       const startingPayload: RawReactionMessageInfo = {
         type: messageTypes.REACTION,
         threadID,
         localID,
         creatorID: viewerID,
         time: Date.now(),
         targetMessageID: messageID,
         reaction,
         action,
       };
 
       void dispatchActionPromise(
         sendReactionMessageActionTypes,
         reactionMessagePromise,
         undefined,
         startingPayload,
       );
     },
     [
       messageID,
       viewerID,
       reactions,
       threadInfo.id,
       threadInfo.type,
       threadInfo.parentThreadID,
       dispatchActionPromise,
       processAndSendDMOperation,
       callSendReactionMessage,
     ],
   );
 }
 
 type ReactionSelectionPopoverPositionArgs = {
   +initialCoordinates: LayoutCoordinates,
   +verticalBounds: VerticalBounds,
   +margin: ?number,
 };
 
 type WritableContainerStyle = {
   position: 'absolute',
   left?: number,
   right?: number,
   bottom?: number,
   top?: number,
   ...
 };
 type ContainerStyle = $ReadOnly<WritableContainerStyle>;
 
 type ReactionSelectionPopoverPosition = {
   +containerStyle: ContainerStyle,
   +popoverLocation: 'above' | 'below',
 };
 function useReactionSelectionPopoverPosition({
   initialCoordinates,
   verticalBounds,
   margin,
 }: ReactionSelectionPopoverPositionArgs): ReactionSelectionPopoverPosition {
   const calculatedMargin = getCalculatedMargin(margin);
 
   const windowWidth = useSelector(state => state.dimensions.width);
 
   const popoverLocation: 'above' | 'below' = (() => {
     const { y, height } = initialCoordinates;
     const contentTop = y;
     const contentBottom = y + height;
     const boundsTop = verticalBounds.y;
     const boundsBottom = verticalBounds.y + verticalBounds.height;
 
     const fullHeight =
       reactionSelectionPopoverDimensions.height + calculatedMargin;
 
     if (
       contentBottom + fullHeight > boundsBottom &&
       contentTop - fullHeight > boundsTop
     ) {
       return 'above';
     }
 
     return 'below';
   })();
 
   const containerStyle = React.useMemo(() => {
     const { x, width, height } = initialCoordinates;
 
     const style: WritableContainerStyle = {
       position: 'absolute',
     };
 
     const extraLeftSpace = x;
     const extraRightSpace = windowWidth - width - x;
     if (extraLeftSpace < extraRightSpace) {
       style.left = 0;
     } else {
       style.right = 0;
     }
 
     if (popoverLocation === 'above') {
       style.bottom = height + calculatedMargin / 2;
     } else {
       style.top = height + calculatedMargin / 2;
     }
 
     return style;
   }, [calculatedMargin, initialCoordinates, popoverLocation, windowWidth]);
   return React.useMemo(
     () => ({
       popoverLocation,
       containerStyle,
     }),
     [popoverLocation, containerStyle],
   );
 }
 
 function getCalculatedMargin(margin: ?number): number {
   return margin ?? 16;
 }
 
 const reactionSelectionPopoverDimensions = {
   height: 56,
   width: 316,
 };
 
 export {
   useSendReaction,
   useReactionSelectionPopoverPosition,
   getCalculatedMargin,
   reactionSelectionPopoverDimensions,
 };
diff --git a/native/input/input-state-container.react.js b/native/input/input-state-container.react.js
index 7d6139511..73043b98e 100644
--- a/native/input/input-state-container.react.js
+++ b/native/input/input-state-container.react.js
@@ -1,1811 +1,1821 @@
 // @flow
 
 import * as FileSystem from 'expo-file-system';
 import invariant from 'invariant';
 import * as React from 'react';
 import { Platform } from 'react-native';
 import { createSelector } from 'reselect';
 
 import {
   createLocalMessageActionType,
   sendMultimediaMessageActionTypes,
   sendTextMessageActionTypes,
 } from 'lib/actions/message-actions.js';
 import { queueReportsActionType } from 'lib/actions/report-actions.js';
 import { useNewThinThread } from 'lib/actions/thread-actions.js';
 import {
   type BlobServiceUploadAction,
   type BlobServiceUploadResult,
   type MultimediaUploadCallbacks,
   type MultimediaUploadExtras,
   updateMultimediaMessageMediaActionType,
   uploadMultimedia,
   useBlobServiceUpload,
 } from 'lib/actions/upload-actions.js';
 import commStaffCommunity from 'lib/facts/comm-staff-community.js';
 import {
   type SendMultimediaMessagePayload,
   useInputStateContainerSendMultimediaMessage,
   useInputStateContainerSendTextMessage,
 } from 'lib/hooks/input-state-container-hooks.js';
 import { useNewThickThread } from 'lib/hooks/thread-hooks.js';
 import type {
   CallSingleKeyserverEndpointOptions,
   CallSingleKeyserverEndpointResponse,
 } from 'lib/keyserver-conn/call-single-keyserver-endpoint.js';
 import { useLegacyAshoatKeyserverCall } from 'lib/keyserver-conn/legacy-keyserver-call.js';
 import { pathFromURI, replaceExtension } from 'lib/media/file-utils.js';
 import {
   getNextLocalUploadID,
   isLocalUploadID,
 } from 'lib/media/media-utils.js';
 import { videoDurationLimit } from 'lib/media/video-utils.js';
 import {
   combineLoadingStatuses,
   createLoadingStatusSelector,
 } from 'lib/selectors/loading-selectors.js';
 import {
   createMediaMessageInfo,
   useMessageCreationSideEffectsFunc,
   getNextLocalID,
 } from 'lib/shared/message-utils.js';
 import type { CreationSideEffectsFunc } from 'lib/shared/messages/message-spec.js';
 import { createRealThreadFromPendingThread } from 'lib/shared/thread-actions-utils.js';
 import {
   patchThreadInfoToIncludeMentionedMembersOfParent,
   threadInfoInsideCommunity,
   threadIsPending,
   threadIsPendingSidebar,
 } from 'lib/shared/thread-utils.js';
 import type { CalendarQuery } from 'lib/types/entry-types.js';
 import type {
   Media,
   MediaMission,
   MediaMissionResult,
   MediaMissionStep,
   NativeMediaSelection,
   UploadMultimediaResult,
 } from 'lib/types/media-types.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import {
   type RawMessageInfo,
   type RawMultimediaMessageInfo,
   type SendMessagePayload,
 } from 'lib/types/message-types.js';
 import type { RawImagesMessageInfo } from 'lib/types/messages/images.js';
 import type { RawMediaMessageInfo } from 'lib/types/messages/media.js';
 import type { RawTextMessageInfo } from 'lib/types/messages/text.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import {
   type ClientMediaMissionReportCreationRequest,
   reportTypes,
 } from 'lib/types/report-types.js';
 import {
   threadTypeIsThick,
   threadTypeIsSidebar,
 } from 'lib/types/thread-types-enum.js';
 import type { ThreadType } from 'lib/types/thread-types-enum.js';
 import {
   type ClientNewThinThreadRequest,
   type NewThreadResult,
   type NewThickThreadRequest,
 } from 'lib/types/thread-types.js';
 import { getConfig } from 'lib/utils/config.js';
-import { cloneError, getMessageForException } from 'lib/utils/errors.js';
+import { getMessageForException, SendMessageError } from 'lib/utils/errors.js';
 import { values } from 'lib/utils/objects.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/redux-promise-utils.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import {
   generateReportID,
   useIsReportEnabled,
 } from 'lib/utils/report-utils.js';
 
 import {
   type EditInputBarMessageParameters,
   type InputState,
   InputStateContext,
   type MessagePendingUploads,
   type MultimediaProcessingStep,
   type PendingMultimediaUploads,
 } from './input-state.js';
 import { encryptMedia } from '../media/encryption-utils.js';
 import { disposeTempFile } from '../media/file-utils.js';
 import { processMedia } from '../media/media-utils.js';
 import { displayActionResultModal } from '../navigation/action-result-modal.js';
 import { useCalendarQuery } from '../navigation/nav-selectors.js';
 import { useSelector } from '../redux/redux-utils.js';
 import blobServiceUploadHandler from '../utils/blob-service-upload.js';
 import { useStaffCanSee } from '../utils/staff-utils.js';
 
 type MediaIDs =
   | { +type: 'photo', +localMediaID: string }
   | { +type: 'video', +localMediaID: string, +localThumbnailID: string };
 type UploadFileInput = {
   +selection: NativeMediaSelection,
   +ids: MediaIDs,
 };
 type WritableCompletedUploads = {
   [localMessageID: string]: ?$ReadOnlySet<string>,
 };
 type CompletedUploads = $ReadOnly<WritableCompletedUploads>;
 type ActiveURI = { +count: number, +onClear: $ReadOnlyArray<() => mixed> };
 
 type BaseProps = {
   +children: React.Node,
 };
 type Props = {
   ...BaseProps,
   +viewerID: ?string,
   +messageStoreMessages: { +[id: string]: RawMessageInfo },
   +ongoingMessageCreation: boolean,
   +hasWiFi: boolean,
   +mediaReportsEnabled: boolean,
   +calendarQuery: () => CalendarQuery,
   +dispatch: Dispatch,
   +staffCanSee: boolean,
   +dispatchActionPromise: DispatchActionPromise,
   +uploadMultimedia: (
     multimedia: Object,
     extras: MultimediaUploadExtras,
     callbacks: MultimediaUploadCallbacks,
   ) => Promise<UploadMultimediaResult>,
   +blobServiceUpload: BlobServiceUploadAction,
   +sendMultimediaMessage: (
     messageInfo: RawMultimediaMessageInfo,
     sidebarCreation: boolean,
     isLegacy: boolean,
   ) => Promise<SendMultimediaMessagePayload>,
   +sendTextMessage: (
     messageInfo: RawTextMessageInfo,
     threadInfo: ThreadInfo,
     parentThreadInfo: ?ThreadInfo,
     sidebarCreation: boolean,
   ) => Promise<SendMessagePayload>,
   +newThinThread: (
     request: ClientNewThinThreadRequest,
   ) => Promise<NewThreadResult>,
   +newThickThread: (request: NewThickThreadRequest) => Promise<string>,
   +textMessageCreationSideEffectsFunc: CreationSideEffectsFunc<RawTextMessageInfo>,
 };
 type State = {
   +pendingUploads: PendingMultimediaUploads,
 };
 
 class InputStateContainer extends React.PureComponent<Props, State> {
   state: State = {
     pendingUploads: {},
   };
   sendCallbacks: Array<() => void> = [];
   activeURIs: Map<string, ActiveURI> = new Map();
   editInputBarCallbacks: Array<
     (params: EditInputBarMessageParameters) => void,
   > = [];
   scrollToMessageCallbacks: Array<(messageID: string) => void> = [];
   pendingThreadCreations: Map<
     string,
     Promise<{
       +threadID: string,
       +threadType: ThreadType,
     }>,
   > = new Map();
   pendingThreadUpdateHandlers: Map<string, (ThreadInfo) => mixed> = new Map();
   // TODO: flip the switch
   // Note that this enables Blob service for encrypted media only
   useBlobServiceUploads = false;
 
   // When the user sends a multimedia message that triggers the creation of a
   // sidebar, the sidebar gets created right away, but the message needs to wait
   // for the uploads to complete before sending. We use this Set to track the
   // message localIDs that need sidebarCreation: true.
   pendingSidebarCreationMessageLocalIDs: Set<string> = new Set();
 
   static getCompletedUploads(props: Props, state: State): CompletedUploads {
     const completedUploads: WritableCompletedUploads = {};
     for (const localMessageID in state.pendingUploads) {
       const messagePendingUploads = state.pendingUploads[localMessageID];
       const rawMessageInfo = props.messageStoreMessages[localMessageID];
       if (!rawMessageInfo) {
         continue;
       }
       invariant(
         rawMessageInfo.type === messageTypes.IMAGES ||
           rawMessageInfo.type === messageTypes.MULTIMEDIA,
         `rawMessageInfo ${localMessageID} should be multimedia`,
       );
 
       let allUploadsComplete = true;
       const completedUploadIDs = new Set(Object.keys(messagePendingUploads));
       for (const singleMedia of rawMessageInfo.media) {
         if (isLocalUploadID(singleMedia.id)) {
           allUploadsComplete = false;
           completedUploadIDs.delete(singleMedia.id);
         }
         const { thumbnailID } = singleMedia;
         if (thumbnailID && isLocalUploadID(thumbnailID)) {
           allUploadsComplete = false;
           completedUploadIDs.delete(thumbnailID);
         }
       }
 
       if (allUploadsComplete) {
         completedUploads[localMessageID] = null;
       } else if (completedUploadIDs.size > 0) {
         completedUploads[localMessageID] = completedUploadIDs;
       }
     }
     return completedUploads;
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     if (this.props.viewerID !== prevProps.viewerID) {
       this.setState({ pendingUploads: {} });
       return;
     }
 
     const currentlyComplete = InputStateContainer.getCompletedUploads(
       this.props,
       this.state,
     );
     const previouslyComplete = InputStateContainer.getCompletedUploads(
       prevProps,
       prevState,
     );
 
     const newPendingUploads: PendingMultimediaUploads = {};
     let pendingUploadsChanged = false;
     const readyMessageIDs = [];
     for (const localMessageID in this.state.pendingUploads) {
       const messagePendingUploads = this.state.pendingUploads[localMessageID];
       const prevRawMessageInfo = prevProps.messageStoreMessages[localMessageID];
       const rawMessageInfo = this.props.messageStoreMessages[localMessageID];
       const completedUploadIDs = currentlyComplete[localMessageID];
       const previouslyCompletedUploadIDs = previouslyComplete[localMessageID];
 
       if (!rawMessageInfo && prevRawMessageInfo) {
         pendingUploadsChanged = true;
         continue;
       } else if (completedUploadIDs === null) {
         // All of this message's uploads have been completed
         newPendingUploads[localMessageID] = {};
         if (previouslyCompletedUploadIDs !== null) {
           readyMessageIDs.push(localMessageID);
           pendingUploadsChanged = true;
         }
         continue;
       } else if (!completedUploadIDs) {
         // Nothing has been completed
         newPendingUploads[localMessageID] = messagePendingUploads;
         continue;
       }
 
       const newUploads: MessagePendingUploads = {};
       let uploadsChanged = false;
       for (const localUploadID in messagePendingUploads) {
         if (!completedUploadIDs.has(localUploadID)) {
           newUploads[localUploadID] = messagePendingUploads[localUploadID];
         } else if (
           !previouslyCompletedUploadIDs ||
           !previouslyCompletedUploadIDs.has(localUploadID)
         ) {
           uploadsChanged = true;
         }
       }
 
       if (uploadsChanged) {
         pendingUploadsChanged = true;
         newPendingUploads[localMessageID] = newUploads;
       } else {
         newPendingUploads[localMessageID] = messagePendingUploads;
       }
     }
     if (pendingUploadsChanged) {
       this.setState({ pendingUploads: newPendingUploads });
     }
 
     for (const localMessageID of readyMessageIDs) {
       const rawMessageInfo = this.props.messageStoreMessages[localMessageID];
       if (!rawMessageInfo) {
         continue;
       }
       invariant(
         rawMessageInfo.type === messageTypes.IMAGES ||
           rawMessageInfo.type === messageTypes.MULTIMEDIA,
         `rawMessageInfo ${localMessageID} should be multimedia`,
       );
       void this.dispatchMultimediaMessageAction(rawMessageInfo);
     }
   }
 
   async dispatchMultimediaMessageAction(
     messageInfo: RawMultimediaMessageInfo,
   ): Promise<void> {
     if (!threadIsPending(messageInfo.threadID)) {
       void this.props.dispatchActionPromise(
         sendMultimediaMessageActionTypes,
         this.sendMultimediaMessageAction(messageInfo),
         undefined,
         messageInfo,
       );
       return;
     }
 
     this.props.dispatch({
       type: sendMultimediaMessageActionTypes.started,
       payload: messageInfo,
     });
 
     let newThreadID = null;
     try {
       const threadCreationPromise = this.pendingThreadCreations.get(
         messageInfo.threadID,
       );
       if (!threadCreationPromise) {
         // When we create or retry multimedia message, we add a promise to
         // pendingThreadCreations map. This promise can be removed in
         // sendMultimediaMessage and sendTextMessage methods. When any of these
         // method remove the promise, it has to be settled. If the promise was
         // fulfilled, this method would be called with realized thread, so we
         // can conclude that the promise was rejected. We don't have enough info
         // here to retry the thread creation, but we can mark the message as
         // failed. Then the retry will be possible and promise will be created
         // again.
         throw new Error('Thread creation failed');
       }
       const result = await threadCreationPromise;
       newThreadID = result.threadID;
     } catch (e) {
-      const copy = cloneError(e);
-      copy.localID = messageInfo.localID;
-      copy.threadID = messageInfo.threadID;
+      const exceptionMessage = getMessageForException(e) ?? '';
+      const payload = new SendMessageError(
+        `Exception while creating thread: ${exceptionMessage}`,
+        messageInfo.localID ?? '',
+        messageInfo.threadID,
+      );
       this.props.dispatch({
         type: sendMultimediaMessageActionTypes.failed,
-        payload: copy,
+        payload,
         error: true,
       });
       return;
     } finally {
       this.pendingThreadCreations.delete(messageInfo.threadID);
     }
 
     const newMessageInfo = {
       ...messageInfo,
       threadID: newThreadID,
       time: Date.now(),
     };
     void this.props.dispatchActionPromise(
       sendMultimediaMessageActionTypes,
       this.sendMultimediaMessageAction(newMessageInfo),
       undefined,
       newMessageInfo,
     );
   }
 
   async sendMultimediaMessageAction(
     messageInfo: RawMultimediaMessageInfo,
   ): Promise<SendMessagePayload> {
     const { localID, threadID } = messageInfo;
     invariant(
       localID !== null && localID !== undefined,
       'localID should be set',
     );
     const sidebarCreation =
       this.pendingSidebarCreationMessageLocalIDs.has(localID);
     try {
       const { result } = await this.props.sendMultimediaMessage(
         messageInfo,
         sidebarCreation,
         false,
       );
       this.pendingSidebarCreationMessageLocalIDs.delete(localID);
       return result;
     } catch (e) {
-      const copy = cloneError(e);
-      copy.localID = localID;
-      copy.threadID = threadID;
-      throw copy;
+      const exceptionMessage = getMessageForException(e) ?? '';
+      throw new SendMessageError(
+        `Exception when sending multimedia message: ${exceptionMessage}`,
+        localID,
+        threadID,
+      );
     }
   }
 
   inputStateSelector: State => InputState = createSelector(
     (state: State) => state.pendingUploads,
     (pendingUploads: PendingMultimediaUploads) =>
       ({
         pendingUploads,
         sendTextMessage: this.sendTextMessage,
         sendMultimediaMessage: this.sendMultimediaMessage,
         editInputMessage: this.editInputMessage,
         addEditInputMessageListener: this.addEditInputMessageListener,
         removeEditInputMessageListener: this.removeEditInputMessageListener,
         messageHasUploadFailure: this.messageHasUploadFailure,
         retryMessage: this.retryMessage,
         registerSendCallback: this.registerSendCallback,
         unregisterSendCallback: this.unregisterSendCallback,
         uploadInProgress: this.uploadInProgress,
         reportURIDisplayed: this.reportURIDisplayed,
         setPendingThreadUpdateHandler: this.setPendingThreadUpdateHandler,
         scrollToMessage: this.scrollToMessage,
         addScrollToMessageListener: this.addScrollToMessageListener,
         removeScrollToMessageListener: this.removeScrollToMessageListener,
       }: InputState),
   );
 
   scrollToMessage = (messageID: string) => {
     this.scrollToMessageCallbacks.forEach(callback => callback(messageID));
   };
 
   addScrollToMessageListener = (callback: (messageID: string) => void) => {
     this.scrollToMessageCallbacks.push(callback);
   };
 
   removeScrollToMessageListener = (
     callbackScrollToMessage: (messageID: string) => void,
   ) => {
     this.scrollToMessageCallbacks = this.scrollToMessageCallbacks.filter(
       candidate => candidate !== callbackScrollToMessage,
     );
   };
 
   uploadInProgress = (): boolean => {
     if (this.props.ongoingMessageCreation) {
       return true;
     }
     const { pendingUploads } = this.state;
     return values(pendingUploads).some(messagePendingUploads =>
       values(messagePendingUploads).some(upload => !upload.failed),
     );
   };
 
   sendTextMessage = async (
     messageInfo: RawTextMessageInfo,
     inputThreadInfo: ThreadInfo,
     parentThreadInfo: ?ThreadInfo,
   ) => {
     this.sendCallbacks.forEach(callback => callback());
 
     const { localID } = messageInfo;
     invariant(
       localID !== null && localID !== undefined,
       'localID should be set',
     );
     if (threadIsPendingSidebar(inputThreadInfo.id)) {
       this.pendingSidebarCreationMessageLocalIDs.add(localID);
     }
 
     if (!threadIsPending(inputThreadInfo.id)) {
       void this.props.dispatchActionPromise(
         sendTextMessageActionTypes,
         this.sendTextMessageAction(
           messageInfo,
           inputThreadInfo,
           parentThreadInfo,
         ),
         undefined,
         messageInfo,
       );
       return;
     }
 
     this.props.dispatch({
       type: sendTextMessageActionTypes.started,
       payload: messageInfo,
     });
 
     let threadInfo = inputThreadInfo;
     const { viewerID } = this.props;
     if (viewerID && threadTypeIsSidebar(inputThreadInfo.type)) {
       invariant(parentThreadInfo, 'sidebar should have parent');
       threadInfo = patchThreadInfoToIncludeMentionedMembersOfParent(
         inputThreadInfo,
         parentThreadInfo,
         messageInfo.text,
         viewerID,
       );
       if (threadInfo !== inputThreadInfo) {
         const pendingThreadUpdateHandler = this.pendingThreadUpdateHandlers.get(
           threadInfo.id,
         );
         pendingThreadUpdateHandler?.(threadInfo);
       }
     }
 
     let threadCreationResult = null;
     try {
       threadCreationResult = await this.startThreadCreation(threadInfo);
     } catch (e) {
-      const copy = cloneError(e);
-      copy.localID = messageInfo.localID;
-      copy.threadID = messageInfo.threadID;
+      const exceptionMessage = getMessageForException(e) ?? '';
+      const payload = new SendMessageError(
+        `Exception while creating thread: ${exceptionMessage}`,
+        messageInfo.localID ?? '',
+        messageInfo.threadID,
+      );
       this.props.dispatch({
         type: sendTextMessageActionTypes.failed,
-        payload: copy,
+        payload,
         error: true,
       });
       return;
     } finally {
       this.pendingThreadCreations.delete(threadInfo.id);
     }
 
     const newMessageInfo = {
       ...messageInfo,
       threadID: threadCreationResult?.threadID,
       time: Date.now(),
     };
 
     const newThreadInfo = {
       ...threadInfo,
       id: threadCreationResult?.threadID,
       type: threadCreationResult?.threadType ?? threadInfo.type,
     };
 
     void this.props.dispatchActionPromise(
       sendTextMessageActionTypes,
       this.sendTextMessageAction(
         newMessageInfo,
         newThreadInfo,
         parentThreadInfo,
       ),
       undefined,
       newMessageInfo,
     );
   };
 
   startThreadCreation(
     threadInfo: ThreadInfo,
   ): Promise<{ +threadID: string, +threadType: ThreadType }> {
     if (!threadIsPending(threadInfo.id)) {
       return Promise.resolve({
         threadID: threadInfo.id,
         threadType: threadInfo.type,
       });
     }
     let threadCreationPromise = this.pendingThreadCreations.get(threadInfo.id);
     if (!threadCreationPromise) {
       const calendarQuery = this.props.calendarQuery();
       threadCreationPromise = createRealThreadFromPendingThread({
         threadInfo,
         dispatchActionPromise: this.props.dispatchActionPromise,
         createNewThinThread: this.props.newThinThread,
         createNewThickThread: this.props.newThickThread,
         sourceMessageID: threadInfo.sourceMessageID,
         viewerID: this.props.viewerID,
         calendarQuery,
       });
       this.pendingThreadCreations.set(threadInfo.id, threadCreationPromise);
     }
     return threadCreationPromise;
   }
 
   async sendTextMessageAction(
     messageInfo: RawTextMessageInfo,
     threadInfo: ThreadInfo,
     parentThreadInfo: ?ThreadInfo,
   ): Promise<SendMessagePayload> {
     try {
       if (!threadTypeIsThick(threadInfo.type)) {
         await this.props.textMessageCreationSideEffectsFunc(
           messageInfo,
           threadInfo,
           parentThreadInfo,
         );
       }
       const { localID } = messageInfo;
       invariant(
         localID !== null && localID !== undefined,
         'localID should be set',
       );
       const sidebarCreation =
         this.pendingSidebarCreationMessageLocalIDs.has(localID);
       const result = await this.props.sendTextMessage(
         messageInfo,
         threadInfo,
         parentThreadInfo,
         sidebarCreation,
       );
       if (threadTypeIsThick(threadInfo.type)) {
         await this.props.textMessageCreationSideEffectsFunc(
           messageInfo,
           threadInfo,
           parentThreadInfo,
         );
       }
       this.pendingSidebarCreationMessageLocalIDs.delete(localID);
       return result;
     } catch (e) {
-      const copy = cloneError(e);
-      copy.localID = messageInfo.localID;
-      copy.threadID = messageInfo.threadID;
-      throw copy;
+      const exceptionMessage = getMessageForException(e) ?? '';
+      throw new SendMessageError(
+        `Exception when sending text message: ${exceptionMessage}`,
+        messageInfo.localID ?? '',
+        messageInfo.threadID,
+      );
     }
   }
 
   shouldEncryptMedia(threadInfo: ThreadInfo): boolean {
     return (
       threadTypeIsThick(threadInfo.type) ||
       threadInfoInsideCommunity(threadInfo, commStaffCommunity.id)
     );
   }
 
   sendMultimediaMessage = async (
     selections: $ReadOnlyArray<NativeMediaSelection>,
     threadInfo: ThreadInfo,
   ) => {
     this.sendCallbacks.forEach(callback => callback());
     const localMessageID = getNextLocalID();
     void this.startThreadCreation(threadInfo);
 
     if (threadIsPendingSidebar(threadInfo.id)) {
       this.pendingSidebarCreationMessageLocalIDs.add(localMessageID);
     }
 
     const uploadFileInputs = [],
       media: Array<Media> = [];
     for (const selection of selections) {
       const localMediaID = getNextLocalUploadID();
       let ids;
       if (
         selection.step === 'photo_library' ||
         selection.step === 'photo_capture' ||
         selection.step === 'photo_paste'
       ) {
         media.push({
           id: localMediaID,
           uri: selection.uri,
           type: 'photo',
           dimensions: selection.dimensions,
           localMediaSelection: selection,
           thumbHash: null,
         });
         ids = { type: 'photo', localMediaID };
       }
       const localThumbnailID = getNextLocalUploadID();
       if (selection.step === 'video_library') {
         media.push({
           id: localMediaID,
           uri: selection.uri,
           type: 'video',
           dimensions: selection.dimensions,
           localMediaSelection: selection,
           loop: false,
           thumbnailID: localThumbnailID,
           thumbnailURI: selection.uri,
           thumbnailThumbHash: null,
         });
         ids = { type: 'video', localMediaID, localThumbnailID };
       }
       invariant(ids, `unexpected MediaSelection ${selection.step}`);
       uploadFileInputs.push({ selection, ids });
     }
 
     const pendingUploads: MessagePendingUploads = {};
     for (const uploadFileInput of uploadFileInputs) {
       const { localMediaID } = uploadFileInput.ids;
       pendingUploads[localMediaID] = {
         failed: false,
         progressPercent: 0,
         processingStep: null,
       };
       if (uploadFileInput.ids.type === 'video') {
         const { localThumbnailID } = uploadFileInput.ids;
         pendingUploads[localThumbnailID] = {
           failed: false,
           progressPercent: 0,
           processingStep: null,
         };
       }
     }
 
     this.setState(
       prevState => {
         return {
           pendingUploads: {
             ...prevState.pendingUploads,
             [localMessageID]: pendingUploads,
           },
         };
       },
       () => {
         const creatorID = this.props.viewerID;
         invariant(creatorID, 'need viewer ID in order to send a message');
         const messageInfo = createMediaMessageInfo(
           {
             localID: localMessageID,
             threadID: threadInfo.id,
             creatorID,
             media,
           },
           { forceMultimediaMessageType: this.shouldEncryptMedia(threadInfo) },
         );
         this.props.dispatch({
           type: createLocalMessageActionType,
           payload: messageInfo,
         });
       },
     );
 
     await this.uploadFiles(localMessageID, uploadFileInputs, threadInfo);
   };
 
   async uploadFiles(
     localMessageID: string,
     uploadFileInputs: $ReadOnlyArray<UploadFileInput>,
     threadInfo: ThreadInfo,
   ) {
     const results = await Promise.all(
       uploadFileInputs.map(uploadFileInput =>
         this.uploadFile(localMessageID, uploadFileInput, threadInfo),
       ),
     );
     const errors = [...new Set(results.filter(Boolean))];
     if (errors.length > 0) {
       displayActionResultModal(errors.join(', ') + ' :(');
     }
   }
 
   async uploadFile(
     localMessageID: string,
     uploadFileInput: UploadFileInput,
     threadInfo: ThreadInfo,
   ): Promise<?string> {
     const { ids, selection } = uploadFileInput;
     const { localMediaID, localThumbnailID } = ids;
     const start = selection.sendTime;
     const steps: Array<MediaMissionStep> = [selection];
     let encryptionSteps: $ReadOnlyArray<MediaMissionStep> = [];
     let serverID;
     let userTime;
     let errorMessage;
     let reportPromise: ?Promise<$ReadOnlyArray<MediaMissionStep>>;
     const filesToDispose = [];
 
     const onUploadFinished = async (result: MediaMissionResult) => {
       if (!this.props.mediaReportsEnabled) {
         return errorMessage;
       }
       if (reportPromise) {
         const finalSteps = await reportPromise;
         steps.push(...finalSteps);
         steps.push(...encryptionSteps);
       }
       const totalTime = Date.now() - start;
       userTime = userTime ? userTime : totalTime;
       this.queueMediaMissionReport(
         { localID: localMediaID, localMessageID, serverID },
         { steps, result, totalTime, userTime },
       );
       return errorMessage;
     };
     const onUploadFailed = (message: string) => {
       errorMessage = message;
       this.handleUploadFailure(localMessageID, localMediaID, localThumbnailID);
       userTime = Date.now() - start;
     };
 
     const onTranscodingProgress = (percent: number) => {
       this.setProgress(localMessageID, localMediaID, 'transcoding', percent);
     };
 
     let processedMedia;
     const processingStart = Date.now();
     try {
       const processMediaReturn = processMedia(selection, {
         hasWiFi: this.props.hasWiFi,
         finalFileHeaderCheck: this.props.staffCanSee,
         onTranscodingProgress,
       });
       reportPromise = processMediaReturn.reportPromise;
       const processResult = await processMediaReturn.resultPromise;
       if (!processResult.success) {
         const message =
           processResult.reason === 'video_too_long'
             ? `can't do vids longer than ${videoDurationLimit}min`
             : 'processing failed';
         onUploadFailed(message);
         return await onUploadFinished(processResult);
       }
       if (processResult.shouldDisposePath) {
         filesToDispose.push(processResult.shouldDisposePath);
       }
       processedMedia = processResult;
     } catch (e) {
       onUploadFailed('processing failed');
       return await onUploadFinished({
         success: false,
         reason: 'processing_exception',
         time: Date.now() - processingStart,
         exceptionMessage: getMessageForException(e),
       });
     }
 
     if (this.shouldEncryptMedia(threadInfo)) {
       const encryptionStart = Date.now();
       try {
         const { result: encryptionResult, ...encryptionReturn } =
           await encryptMedia(processedMedia);
         encryptionSteps = encryptionReturn.steps;
         if (!encryptionResult.success) {
           onUploadFailed(encryptionResult.reason);
           return await onUploadFinished(encryptionResult);
         }
         if (encryptionResult.shouldDisposePath) {
           filesToDispose.push(encryptionResult.shouldDisposePath);
         }
         processedMedia = encryptionResult;
       } catch (e) {
         onUploadFailed('encryption failed');
         return await onUploadFinished({
           success: false,
           reason: 'encryption_exception',
           time: Date.now() - encryptionStart,
           exceptionMessage: getMessageForException(e),
         });
       }
     }
 
     const { uploadURI, filename, mime } = processedMedia;
 
     const { hasWiFi } = this.props;
 
     const uploadStart = Date.now();
     let uploadExceptionMessage,
       uploadResult,
       uploadThumbnailResult,
       mediaMissionResult;
 
     const isThickThread = threadTypeIsThick(threadInfo.type);
     const useBlobService = isThickThread || this.useBlobServiceUploads;
     try {
       if (
         useBlobService &&
         (processedMedia.mediaType === 'encrypted_photo' ||
           processedMedia.mediaType === 'encrypted_video')
       ) {
         const uploadMetadataToKeyserver = !isThickThread;
         const uploadPromise = this.props.blobServiceUpload({
           uploadInput: {
             blobInput: {
               type: 'uri',
               uri: uploadURI,
               filename: filename,
               mimeType: mime,
             },
             blobHash: processedMedia.blobHash,
             encryptionKey: processedMedia.encryptionKey,
             dimensions: processedMedia.dimensions,
             thumbHash:
               processedMedia.mediaType === 'encrypted_photo'
                 ? processedMedia.thumbHash
                 : null,
           },
           keyserverOrThreadID: uploadMetadataToKeyserver ? threadInfo.id : null,
           callbacks: {
             blobServiceUploadHandler,
             onProgress: (percent: number) => {
               this.setProgress(
                 localMessageID,
                 localMediaID,
                 'uploading',
                 percent,
               );
             },
           },
         });
 
         const uploadThumbnailPromise: Promise<?BlobServiceUploadResult> =
           (async () => {
             if (processedMedia.mediaType !== 'encrypted_video') {
               return undefined;
             }
             return await this.props.blobServiceUpload({
               uploadInput: {
                 blobInput: {
                   type: 'uri',
                   uri: processedMedia.uploadThumbnailURI,
                   filename: replaceExtension(`thumb${filename}`, 'jpg'),
                   mimeType: 'image/jpeg',
                 },
                 blobHash: processedMedia.thumbnailBlobHash,
                 encryptionKey: processedMedia.thumbnailEncryptionKey,
                 loop: false,
                 dimensions: processedMedia.dimensions,
                 thumbHash: processedMedia.thumbHash,
               },
               keyserverOrThreadID: uploadMetadataToKeyserver
                 ? threadInfo.id
                 : null,
               callbacks: {
                 blobServiceUploadHandler,
               },
             });
           })();
 
         [uploadResult, uploadThumbnailResult] = await Promise.all([
           uploadPromise,
           uploadThumbnailPromise,
         ]);
       } else {
         const uploadPromise = this.props.uploadMultimedia(
           { uri: uploadURI, name: filename, type: mime },
           {
             ...processedMedia.dimensions,
             loop:
               processedMedia.mediaType === 'video' ||
               processedMedia.mediaType === 'encrypted_video'
                 ? processedMedia.loop
                 : undefined,
             encryptionKey: processedMedia.encryptionKey,
             thumbHash:
               processedMedia.mediaType === 'photo' ||
               processedMedia.mediaType === 'encrypted_photo'
                 ? processedMedia.thumbHash
                 : null,
           },
           {
             onProgress: (percent: number) =>
               this.setProgress(
                 localMessageID,
                 localMediaID,
                 'uploading',
                 percent,
               ),
             performHTTPMultipartUpload: this.performHTTPMultipartUpload,
           },
         );
 
         const uploadThumbnailPromise: Promise<?UploadMultimediaResult> =
           (async () => {
             if (
               processedMedia.mediaType !== 'video' &&
               processedMedia.mediaType !== 'encrypted_video'
             ) {
               return undefined;
             }
             return await this.props.uploadMultimedia(
               {
                 uri: processedMedia.uploadThumbnailURI,
                 name: replaceExtension(`thumb${filename}`, 'jpg'),
                 type: 'image/jpeg',
               },
               {
                 ...processedMedia.dimensions,
                 loop: false,
                 encryptionKey: processedMedia.thumbnailEncryptionKey,
                 thumbHash: processedMedia.thumbHash,
               },
               {
                 performHTTPMultipartUpload: this.performHTTPMultipartUpload,
               },
             );
           })();
 
         [uploadResult, uploadThumbnailResult] = await Promise.all([
           uploadPromise,
           uploadThumbnailPromise,
         ]);
       }
       mediaMissionResult = { success: true };
     } catch (e) {
       uploadExceptionMessage = getMessageForException(e);
       onUploadFailed('upload failed');
       mediaMissionResult = {
         success: false,
         reason: 'http_upload_failed',
         exceptionMessage: uploadExceptionMessage,
       };
     }
 
     if (
       ((processedMedia.mediaType === 'photo' ||
         processedMedia.mediaType === 'encrypted_photo') &&
         uploadResult) ||
       ((processedMedia.mediaType === 'video' ||
         processedMedia.mediaType === 'encrypted_video') &&
         uploadResult &&
         uploadThumbnailResult)
     ) {
       const { encryptionKey } = processedMedia;
       const { id, uri, dimensions, loop } = uploadResult;
       serverID = id;
 
       const mediaSourcePayload =
         processedMedia.mediaType === 'encrypted_photo' ||
         processedMedia.mediaType === 'encrypted_video'
           ? {
               type: processedMedia.mediaType,
               blobURI: uri,
               encryptionKey,
             }
           : {
               type: uploadResult.mediaType,
               uri,
             };
       let updateMediaPayload = {
         messageID: localMessageID,
         currentMediaID: localMediaID,
         mediaUpdate: {
           id,
           ...mediaSourcePayload,
           dimensions,
           localMediaSelection: undefined,
           loop: uploadResult.mediaType === 'video' ? loop : undefined,
         },
       };
 
       if (
         processedMedia.mediaType === 'video' ||
         processedMedia.mediaType === 'encrypted_video'
       ) {
         invariant(uploadThumbnailResult, 'uploadThumbnailResult exists');
         const { uri: thumbnailURI, id: thumbnailID } = uploadThumbnailResult;
         const { thumbnailEncryptionKey, thumbHash: thumbnailThumbHash } =
           processedMedia;
 
         if (processedMedia.mediaType === 'encrypted_video') {
           updateMediaPayload = {
             ...updateMediaPayload,
             mediaUpdate: {
               ...updateMediaPayload.mediaUpdate,
               thumbnailID,
               thumbnailBlobURI: thumbnailURI,
               thumbnailEncryptionKey,
               thumbnailThumbHash,
             },
           };
         } else {
           updateMediaPayload = {
             ...updateMediaPayload,
             mediaUpdate: {
               ...updateMediaPayload.mediaUpdate,
               thumbnailID,
               thumbnailURI,
               thumbnailThumbHash,
             },
           };
         }
       } else {
         updateMediaPayload = {
           ...updateMediaPayload,
           mediaUpdate: {
             ...updateMediaPayload.mediaUpdate,
             thumbHash: processedMedia.thumbHash,
           },
         };
       }
 
       // When we dispatch this action, it updates Redux and triggers the
       // componentDidUpdate in this class. componentDidUpdate will handle
       // calling dispatchMultimediaMessageAction once all the uploads are
       // complete, and does not wait until this function concludes.
       this.props.dispatch({
         type: updateMultimediaMessageMediaActionType,
         payload: updateMediaPayload,
       });
       userTime = Date.now() - start;
     }
 
     const processSteps = await reportPromise;
     reportPromise = null;
     steps.push(...processSteps);
     steps.push(...encryptionSteps);
     steps.push({
       step: 'upload',
       success: !!uploadResult,
       exceptionMessage: uploadExceptionMessage,
       time: Date.now() - uploadStart,
       inputFilename: filename,
       outputMediaType: uploadResult && uploadResult.mediaType,
       outputURI: uploadResult && uploadResult.uri,
       outputDimensions: uploadResult && uploadResult.dimensions,
       outputLoop: uploadResult && uploadResult.loop,
       hasWiFi,
     });
 
     const cleanupPromises = [];
 
     if (filesToDispose.length > 0) {
       // If processMedia needed to do any transcoding before upload, we dispose
       // of the resultant temporary file here. Since the transcoded temporary
       // file is only used for upload, we can dispose of it after processMedia
       // (reportPromise) and the upload are complete
       filesToDispose.forEach(shouldDisposePath => {
         cleanupPromises.push(
           (async () => {
             const disposeStep = await disposeTempFile(shouldDisposePath);
             steps.push(disposeStep);
           })(),
         );
       });
     }
 
     // if there's a thumbnail we'll temporarily unlink it here
     // instead of in media-utils, will be changed in later diffs
     if (processedMedia.mediaType === 'video') {
       const { uploadThumbnailURI } = processedMedia;
       cleanupPromises.push(
         (async () => {
           const { steps: clearSteps, result: thumbnailPath } =
             await this.waitForCaptureURIUnload(uploadThumbnailURI);
           steps.push(...clearSteps);
           if (!thumbnailPath) {
             return;
           }
           const disposeStep = await disposeTempFile(thumbnailPath);
           steps.push(disposeStep);
         })(),
       );
     }
 
     if (selection.captureTime || selection.step === 'photo_paste') {
       // If we are uploading a newly captured photo, we dispose of the original
       // file here. Note that we try to save photo captures to the camera roll
       // if we have permission. Even if we fail, this temporary file isn't
       // visible to the user, so there's no point in keeping it around. Since
       // the initial URI is used in rendering paths, we have to wait for it to
       // be replaced with the remote URI before we can dispose. Check out the
       // Multimedia component to see how the URIs get switched out.
       const captureURI = selection.uri;
       cleanupPromises.push(
         (async () => {
           const { steps: clearSteps, result: capturePath } =
             await this.waitForCaptureURIUnload(captureURI);
           steps.push(...clearSteps);
           if (!capturePath) {
             return;
           }
           const disposeStep = await disposeTempFile(capturePath);
           steps.push(disposeStep);
         })(),
       );
     }
 
     await Promise.all(cleanupPromises);
 
     return await onUploadFinished(mediaMissionResult);
   }
 
   setProgress(
     localMessageID: string,
     localUploadID: string,
     processingStep: MultimediaProcessingStep,
     progressPercent: number,
   ) {
     this.setState(prevState => {
       const pendingUploads = prevState.pendingUploads[localMessageID];
       if (!pendingUploads) {
         return {};
       }
       const pendingUpload = pendingUploads[localUploadID];
       if (!pendingUpload) {
         return {};
       }
       const newOutOfHundred = Math.floor(progressPercent * 100);
       const oldOutOfHundred = Math.floor(pendingUpload.progressPercent * 100);
       if (newOutOfHundred === oldOutOfHundred) {
         return {};
       }
       const newPendingUploads = {
         ...pendingUploads,
         [localUploadID]: {
           ...pendingUpload,
           progressPercent,
           processingStep,
         },
       };
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [localMessageID]: newPendingUploads,
         },
       };
     });
   }
 
   performHTTPMultipartUpload = async (
     url: string,
     cookie: ?string,
     sessionID: ?string,
     input: { +[key: string]: mixed },
     options?: ?CallSingleKeyserverEndpointOptions,
   ): Promise<CallSingleKeyserverEndpointResponse> => {
     invariant(
       cookie &&
         input.multimedia &&
         Array.isArray(input.multimedia) &&
         input.multimedia.length === 1 &&
         input.multimedia[0] &&
         typeof input.multimedia[0] === 'object',
       'InputStateContainer.performHTTPMultipartUpload sent incorrect input',
     );
     const { uri, name, type } = input.multimedia[0];
     invariant(
       typeof uri === 'string' &&
         typeof name === 'string' &&
         typeof type === 'string',
       'InputStateContainer.performHTTPMultipartUpload sent incorrect input',
     );
 
     const parameters: { [key: string]: mixed } = {};
     parameters.cookie = cookie;
     parameters.filename = name;
 
     for (const key in input) {
       if (
         key === 'multimedia' ||
         key === 'cookie' ||
         key === 'sessionID' ||
         key === 'filename'
       ) {
         continue;
       }
       const value = input[key];
       invariant(
         typeof value === 'string',
         'performHTTPMultipartUpload calls can only handle string values for ' +
           'non-multimedia keys',
       );
       parameters[key] = value;
     }
 
     let path = uri;
     if (Platform.OS === 'android') {
       const resolvedPath = pathFromURI(uri);
       if (resolvedPath) {
         path = resolvedPath;
       }
     }
 
     let uploadOptions = {
       uploadType: FileSystem.FileSystemUploadType.MULTIPART,
       fieldName: 'multimedia',
       headers: {
         Accept: 'application/json',
       },
       parameters,
     };
     if (Platform.OS === 'android' && path.endsWith('.dat')) {
       // expo-file-system is not able to deduce the MIME type of .dat files, so
       // we specify it explicitly here. Without this, we get this error:
       //   guessContentTypeFromName(file.name) must not be null
       uploadOptions = {
         ...uploadOptions,
         mimeType: 'application/octet-stream',
       };
     }
 
     const uploadTask = FileSystem.createUploadTask(
       url,
       path,
       uploadOptions,
       uploadProgress => {
         if (options && options.onProgress) {
           const { totalByteSent, totalBytesExpectedToSend } = uploadProgress;
           options.onProgress(totalByteSent / totalBytesExpectedToSend);
         }
       },
     );
     if (options && options.abortHandler) {
       options.abortHandler(() => uploadTask.cancelAsync());
     }
     try {
       const response = await uploadTask.uploadAsync();
       return JSON.parse(response.body);
     } catch (e) {
       throw new Error(
         `Failed to upload blob: ${
           getMessageForException(e) ?? 'unknown error'
         }`,
       );
     }
   };
 
   handleUploadFailure(
     localMessageID: string,
     localUploadID: string,
     localThumbnailID: ?string,
   ) {
     this.setState(prevState => {
       const uploads = prevState.pendingUploads[localMessageID];
 
       const upload = uploads[localUploadID];
       const thumbnailUpload = localThumbnailID
         ? uploads[localThumbnailID]
         : undefined;
       if (!upload && !thumbnailUpload) {
         // The upload has been completed before it failed
         return {};
       }
 
       const newUploads = { ...uploads };
       newUploads[localUploadID] = {
         ...upload,
         failed: true,
         progressPercent: 0,
       };
       if (localThumbnailID) {
         newUploads[localThumbnailID] = {
           processingStep: null,
           ...thumbnailUpload,
           failed: true,
           progressPercent: 0,
         };
       }
 
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [localMessageID]: newUploads,
         },
       };
     });
   }
 
   queueMediaMissionReport(
     ids: { localID: string, localMessageID: string, serverID: ?string },
     mediaMission: MediaMission,
   ) {
     const report: ClientMediaMissionReportCreationRequest = {
       type: reportTypes.MEDIA_MISSION,
       time: Date.now(),
       platformDetails: getConfig().platformDetails,
       mediaMission,
       uploadServerID: ids.serverID,
       uploadLocalID: ids.localID,
       messageLocalID: ids.localMessageID,
       id: generateReportID(),
     };
     this.props.dispatch({
       type: queueReportsActionType,
       payload: {
         reports: [report],
       },
     });
   }
 
   messageHasUploadFailure = (localMessageID: string): boolean => {
     const pendingUploads = this.state.pendingUploads[localMessageID];
     if (!pendingUploads) {
       return false;
     }
     return values(pendingUploads).some(upload => upload.failed);
   };
 
   editInputMessage = (params: EditInputBarMessageParameters) => {
     this.editInputBarCallbacks.forEach(addEditInputBarCallback =>
       addEditInputBarCallback(params),
     );
   };
 
   addEditInputMessageListener = (
     callbackEditInputBar: (params: EditInputBarMessageParameters) => void,
   ) => {
     this.editInputBarCallbacks.push(callbackEditInputBar);
   };
 
   removeEditInputMessageListener = (
     callbackEditInputBar: (params: EditInputBarMessageParameters) => void,
   ) => {
     this.editInputBarCallbacks = this.editInputBarCallbacks.filter(
       candidate => candidate !== callbackEditInputBar,
     );
   };
 
   retryTextMessage = async (
     rawMessageInfo: RawTextMessageInfo,
     threadInfo: ThreadInfo,
     parentThreadInfo: ?ThreadInfo,
   ) => {
     await this.sendTextMessage(
       {
         ...rawMessageInfo,
         time: Date.now(),
       },
       threadInfo,
       parentThreadInfo,
     );
   };
 
   retryMultimediaMessage = async (
     rawMessageInfo: RawMultimediaMessageInfo,
     localMessageID: string,
     threadInfo: ThreadInfo,
   ): Promise<void> => {
     const pendingUploads = this.state.pendingUploads[localMessageID] ?? {};
 
     const now = Date.now();
 
     void this.startThreadCreation(threadInfo);
 
     if (threadIsPendingSidebar(threadInfo.id)) {
       this.pendingSidebarCreationMessageLocalIDs.add(localMessageID);
     }
 
     const updateMedia = <T: Media>(media: $ReadOnlyArray<T>): T[] =>
       media.map(singleMedia => {
         invariant(
           singleMedia.type === 'photo' || singleMedia.type === 'video',
           'Retry selection must be unencrypted',
         );
 
         let updatedMedia = singleMedia;
 
         const oldMediaID = updatedMedia.id;
         if (
           // not complete
           isLocalUploadID(oldMediaID) &&
           // not still ongoing
           (!pendingUploads[oldMediaID] || pendingUploads[oldMediaID].failed)
         ) {
           // If we have an incomplete upload that isn't in pendingUploads, that
           // indicates the app has restarted. We'll reassign a new localID to
           // avoid collisions. Note that this isn't necessary for the message ID
           // since the localID reducer prevents collisions there
           const mediaID = pendingUploads[oldMediaID]
             ? oldMediaID
             : getNextLocalUploadID();
           if (updatedMedia.type === 'photo') {
             updatedMedia = {
               type: 'photo',
               ...updatedMedia,
               id: mediaID,
             };
           } else {
             updatedMedia = {
               type: 'video',
               ...updatedMedia,
               id: mediaID,
             };
           }
         }
 
         if (updatedMedia.type === 'video') {
           const oldThumbnailID = updatedMedia.thumbnailID;
           invariant(oldThumbnailID, 'oldThumbnailID not null or undefined');
           if (
             // not complete
             isLocalUploadID(oldThumbnailID) &&
             // not still ongoing
             (!pendingUploads[oldThumbnailID] ||
               pendingUploads[oldThumbnailID].failed)
           ) {
             const thumbnailID = pendingUploads[oldThumbnailID]
               ? oldThumbnailID
               : getNextLocalUploadID();
             updatedMedia = {
               ...updatedMedia,
               thumbnailID,
             };
           }
         }
 
         if (updatedMedia === singleMedia) {
           return singleMedia;
         }
 
         const oldSelection = updatedMedia.localMediaSelection;
         invariant(
           oldSelection,
           'localMediaSelection should be set on locally created Media',
         );
         const retries = oldSelection.retries ? oldSelection.retries + 1 : 1;
 
         // We switch for Flow
         let selection;
         if (oldSelection.step === 'photo_capture') {
           selection = { ...oldSelection, sendTime: now, retries };
         } else if (oldSelection.step === 'photo_library') {
           selection = { ...oldSelection, sendTime: now, retries };
         } else if (oldSelection.step === 'photo_paste') {
           selection = { ...oldSelection, sendTime: now, retries };
         } else {
           selection = { ...oldSelection, sendTime: now, retries };
         }
 
         if (updatedMedia.type === 'photo') {
           return {
             type: 'photo',
             ...updatedMedia,
             localMediaSelection: selection,
           };
         }
         return {
           type: 'video',
           ...updatedMedia,
           localMediaSelection: selection,
         };
       });
 
     let newRawMessageInfo;
     // This conditional is for Flow
     if (rawMessageInfo.type === messageTypes.MULTIMEDIA) {
       newRawMessageInfo = ({
         ...rawMessageInfo,
         time: now,
         media: updateMedia(rawMessageInfo.media),
       }: RawMediaMessageInfo);
     } else if (rawMessageInfo.type === messageTypes.IMAGES) {
       newRawMessageInfo = ({
         ...rawMessageInfo,
         time: now,
         media: updateMedia(rawMessageInfo.media),
       }: RawImagesMessageInfo);
     } else {
       invariant(false, `rawMessageInfo ${localMessageID} should be multimedia`);
     }
 
     const incompleteMedia: Media[] = [];
     for (const singleMedia of newRawMessageInfo.media) {
       if (isLocalUploadID(singleMedia.id)) {
         incompleteMedia.push(singleMedia);
       }
     }
     if (incompleteMedia.length === 0) {
       void this.dispatchMultimediaMessageAction(newRawMessageInfo);
       this.setState(prevState => ({
         pendingUploads: {
           ...prevState.pendingUploads,
           [localMessageID]: {},
         },
       }));
       return;
     }
 
     const retryMedia = incompleteMedia.filter(
       ({ id }) => !pendingUploads[id] || pendingUploads[id].failed,
     );
     if (retryMedia.length === 0) {
       // All media are already in the process of being uploaded
       return;
     }
 
     // We're not actually starting the send here,
     // we just use this action to update the message in Redux
     this.props.dispatch({
       type: sendMultimediaMessageActionTypes.started,
       payload: newRawMessageInfo,
     });
 
     // We clear out the failed status on individual media here,
     // which makes the UI show pending status instead of error messages
     for (const singleMedia of retryMedia) {
       pendingUploads[singleMedia.id] = {
         failed: false,
         progressPercent: 0,
         processingStep: null,
       };
       if (singleMedia.type === 'video') {
         const { thumbnailID } = singleMedia;
         invariant(thumbnailID, 'thumbnailID not null or undefined');
         pendingUploads[thumbnailID] = {
           failed: false,
           progressPercent: 0,
           processingStep: null,
         };
       }
     }
     this.setState(prevState => ({
       pendingUploads: {
         ...prevState.pendingUploads,
         [localMessageID]: pendingUploads,
       },
     }));
 
     const uploadFileInputs = retryMedia.map(singleMedia => {
       invariant(
         singleMedia.localMediaSelection,
         'localMediaSelection should be set on locally created Media',
       );
 
       let ids;
       if (singleMedia.type === 'photo') {
         ids = { type: 'photo', localMediaID: singleMedia.id };
       } else {
         invariant(
           singleMedia.thumbnailID,
           'singleMedia.thumbnailID should be set for videos',
         );
         ids = {
           type: 'video',
           localMediaID: singleMedia.id,
           localThumbnailID: singleMedia.thumbnailID,
         };
       }
 
       return {
         selection: singleMedia.localMediaSelection,
         ids,
       };
     });
 
     await this.uploadFiles(localMessageID, uploadFileInputs, threadInfo);
   };
 
   retryMessage = async (
     localMessageID: string,
     threadInfo: ThreadInfo,
     parentThreadInfo: ?ThreadInfo,
   ) => {
     this.sendCallbacks.forEach(callback => callback());
 
     const rawMessageInfo = this.props.messageStoreMessages[localMessageID];
     invariant(rawMessageInfo, `rawMessageInfo ${localMessageID} should exist`);
 
     if (rawMessageInfo.type === messageTypes.TEXT) {
       await this.retryTextMessage(rawMessageInfo, threadInfo, parentThreadInfo);
     } else if (
       rawMessageInfo.type === messageTypes.IMAGES ||
       rawMessageInfo.type === messageTypes.MULTIMEDIA
     ) {
       await this.retryMultimediaMessage(
         rawMessageInfo,
         localMessageID,
         threadInfo,
       );
     }
   };
 
   registerSendCallback = (callback: () => void) => {
     this.sendCallbacks.push(callback);
   };
 
   unregisterSendCallback = (callback: () => void) => {
     this.sendCallbacks = this.sendCallbacks.filter(
       candidate => candidate !== callback,
     );
   };
 
   reportURIDisplayed = (uri: string, loaded: boolean) => {
     const prevActiveURI = this.activeURIs.get(uri);
     const curCount = prevActiveURI && prevActiveURI.count;
     const prevCount = curCount ? curCount : 0;
     const count = loaded ? prevCount + 1 : prevCount - 1;
     const prevOnClear = prevActiveURI && prevActiveURI.onClear;
     const onClear = prevOnClear ? prevOnClear : [];
     const activeURI = { count, onClear };
     if (count) {
       this.activeURIs.set(uri, activeURI);
       return;
     }
     this.activeURIs.delete(uri);
     for (const callback of onClear) {
       callback();
     }
   };
 
   waitForCaptureURIUnload(uri: string): Promise<{
     +steps: $ReadOnlyArray<MediaMissionStep>,
     +result: ?string,
   }> {
     const start = Date.now();
     const path = pathFromURI(uri);
     if (!path) {
       return Promise.resolve({
         result: null,
         steps: [
           {
             step: 'wait_for_capture_uri_unload',
             success: false,
             time: Date.now() - start,
             uri,
           },
         ],
       });
     }
 
     const getResult = () => ({
       result: path,
       steps: [
         {
           step: 'wait_for_capture_uri_unload',
           success: true,
           time: Date.now() - start,
           uri,
         },
       ],
     });
 
     const activeURI = this.activeURIs.get(uri);
     if (!activeURI) {
       return Promise.resolve(getResult());
     }
 
     return new Promise(resolve => {
       const finish = () => resolve(getResult());
       const newActiveURI = {
         ...activeURI,
         onClear: [...activeURI.onClear, finish],
       };
       this.activeURIs.set(uri, newActiveURI);
     });
   }
 
   setPendingThreadUpdateHandler = (
     threadID: string,
     pendingThreadUpdateHandler: ?(ThreadInfo) => mixed,
   ) => {
     if (!pendingThreadUpdateHandler) {
       this.pendingThreadUpdateHandlers.delete(threadID);
     } else {
       this.pendingThreadUpdateHandlers.set(
         threadID,
         pendingThreadUpdateHandler,
       );
     }
   };
 
   render(): React.Node {
     const inputState = this.inputStateSelector(this.state);
     return (
       <InputStateContext.Provider value={inputState}>
         {this.props.children}
       </InputStateContext.Provider>
     );
   }
 }
 
 const mediaCreationLoadingStatusSelector = createLoadingStatusSelector(
   sendMultimediaMessageActionTypes,
 );
 const textCreationLoadingStatusSelector = createLoadingStatusSelector(
   sendTextMessageActionTypes,
 );
 
 const ConnectedInputStateContainer: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedInputStateContainer(
     props: BaseProps,
   ) {
     const viewerID = useSelector(
       state => state.currentUserInfo && state.currentUserInfo.id,
     );
     const messageStoreMessages = useSelector(
       state => state.messageStore.messages,
     );
     const ongoingMessageCreation = useSelector(
       state =>
         combineLoadingStatuses(
           mediaCreationLoadingStatusSelector(state),
           textCreationLoadingStatusSelector(state),
         ) === 'loading',
     );
     const hasWiFi = useSelector(state => state.connectivity.hasWiFi);
     const calendarQuery = useCalendarQuery();
     const callUploadMultimedia = useLegacyAshoatKeyserverCall(uploadMultimedia);
     const callBlobServiceUpload = useBlobServiceUpload();
     const callSendMultimediaMessage =
       useInputStateContainerSendMultimediaMessage();
     const callSendTextMessage = useInputStateContainerSendTextMessage();
     const callNewThinThread = useNewThinThread();
     const callNewThickThread = useNewThickThread();
     const dispatchActionPromise = useDispatchActionPromise();
     const dispatch = useDispatch();
     const mediaReportsEnabled = useIsReportEnabled('mediaReports');
     const staffCanSee = useStaffCanSee();
     const textMessageCreationSideEffectsFunc =
       useMessageCreationSideEffectsFunc<RawTextMessageInfo>(messageTypes.TEXT);
 
     return (
       <InputStateContainer
         {...props}
         viewerID={viewerID}
         messageStoreMessages={messageStoreMessages}
         ongoingMessageCreation={ongoingMessageCreation}
         hasWiFi={hasWiFi}
         mediaReportsEnabled={mediaReportsEnabled}
         calendarQuery={calendarQuery}
         uploadMultimedia={callUploadMultimedia}
         blobServiceUpload={callBlobServiceUpload}
         sendMultimediaMessage={callSendMultimediaMessage}
         sendTextMessage={callSendTextMessage}
         newThinThread={callNewThinThread}
         newThickThread={callNewThickThread}
         dispatchActionPromise={dispatchActionPromise}
         dispatch={dispatch}
         staffCanSee={staffCanSee}
         textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc}
       />
     );
   });
 
 export default ConnectedInputStateContainer;
diff --git a/web/chat/reaction-message-utils.js b/web/chat/reaction-message-utils.js
index ec578d5a7..7a87bcaf8 100644
--- a/web/chat/reaction-message-utils.js
+++ b/web/chat/reaction-message-utils.js
@@ -1,261 +1,262 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import uuid from 'uuid';
 
 import {
   useSendReactionMessage,
   sendReactionMessageActionTypes,
 } from 'lib/actions/message-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import type { ReactionInfo } from 'lib/selectors/chat-selectors';
 import {
   dmOperationSpecificationTypes,
   type OutboundDMOperationSpecification,
 } from 'lib/shared/dm-ops/dm-op-utils.js';
 import { useProcessAndSendDMOperation } from 'lib/shared/dm-ops/process-dm-ops.js';
 import { getNextLocalID } from 'lib/shared/message-utils.js';
 import { type DMSendReactionMessageOperation } from 'lib/types/dm-ops.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import type { RawReactionMessageInfo } from 'lib/types/messages/reaction.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
 import {
   thickThreadTypes,
   threadTypeIsThick,
 } from 'lib/types/thread-types-enum.js';
-import { cloneError } from 'lib/utils/errors.js';
+import { SendMessageError, getMessageForException } from 'lib/utils/errors.js';
 import { useDispatchActionPromise } from 'lib/utils/redux-promise-utils.js';
 
 import Alert from '../modals/alert.react.js';
 import { useSelector } from '../redux/redux-utils.js';
 import {
   type TooltipSize,
   type TooltipPositionStyle,
 } from '../tooltips/tooltip-utils.js';
 import { getAppContainerPositionInfo } from '../utils/window-utils.js';
 
 function useSendReaction(
   messageID: ?string,
   threadInfo: ThreadInfo,
   reactions: ReactionInfo,
 ): (reaction: string) => mixed {
   const { pushModal } = useModalContext();
 
   const viewerID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
 
   const callSendReactionMessage = useSendReactionMessage();
   const dispatchActionPromise = useDispatchActionPromise();
   const processAndSendDMOperation = useProcessAndSendDMOperation();
 
   return React.useCallback(
     reaction => {
       if (!messageID) {
         return;
       }
 
       const localID = getNextLocalID();
 
       invariant(viewerID, 'viewerID should be set');
 
       const viewerReacted = reactions[reaction]
         ? reactions[reaction].viewerReacted
         : false;
       const action = viewerReacted ? 'remove_reaction' : 'add_reaction';
 
       const threadID = threadInfo.id;
 
       if (threadTypeIsThick(threadInfo.type)) {
         const op: DMSendReactionMessageOperation = {
           type: 'send_reaction_message',
           threadID,
           creatorID: viewerID,
           time: Date.now(),
           messageID: uuid.v4(),
           targetMessageID: messageID,
           reaction,
           action,
         };
         const opSpecification: OutboundDMOperationSpecification = {
           type: dmOperationSpecificationTypes.OUTBOUND,
           op,
           recipients: {
             type: 'all_thread_members',
             threadID:
               threadInfo.type === thickThreadTypes.THICK_SIDEBAR &&
               threadInfo.parentThreadID
                 ? threadInfo.parentThreadID
                 : threadInfo.id,
           },
         };
         void processAndSendDMOperation(opSpecification);
         return;
       }
 
       const reactionMessagePromise = (async () => {
         try {
           const result = await callSendReactionMessage({
             threadID,
             localID,
             targetMessageID: messageID,
             reaction,
             action,
           });
           const serverID: string = result.id;
           const time: number = result.time;
           return {
             localID,
             serverID,
             threadID,
             time,
           };
         } catch (e) {
           pushModal(
             <Alert title="Couldn’t send the reaction">
               Please try again later
             </Alert>,
           );
-
-          const copy = cloneError(e);
-          copy.localID = localID;
-          copy.threadID = threadID;
-          throw copy;
+          const exceptionMessage = getMessageForException(e) ?? '';
+          throw new SendMessageError(
+            `Exception while sending reaction: ${exceptionMessage}`,
+            localID,
+            threadID,
+          );
         }
       })();
 
       const startingPayload: RawReactionMessageInfo = {
         type: messageTypes.REACTION,
         threadID,
         localID,
         creatorID: viewerID,
         time: Date.now(),
         targetMessageID: messageID,
         reaction,
         action,
       };
 
       void dispatchActionPromise(
         sendReactionMessageActionTypes,
         reactionMessagePromise,
         undefined,
         startingPayload,
       );
     },
     [
       messageID,
       viewerID,
       reactions,
       threadInfo.id,
       threadInfo.type,
       threadInfo.parentThreadID,
       dispatchActionPromise,
       processAndSendDMOperation,
       callSendReactionMessage,
       pushModal,
     ],
   );
 }
 
 type EmojiKeyboardPosition = {
   +bottom: number,
   +left: number,
 };
 
 function getEmojiKeyboardPosition(
   emojiKeyboard: ?HTMLDivElement,
   tooltipPositionStyle: TooltipPositionStyle,
   tooltipSize: TooltipSize,
 ): ?EmojiKeyboardPosition {
   const { alignment, anchorPoint } = tooltipPositionStyle;
   const tooltipAnchorX = anchorPoint.x;
   const tooltipAnchorY = anchorPoint.y;
 
   const tooltipWidth = tooltipSize.width;
   const tooltipHeight = tooltipSize.height;
 
   const appContainerPositionInfo = getAppContainerPositionInfo();
 
   if (!appContainerPositionInfo) {
     return null;
   }
 
   let emojiKeyboardWidth = 352;
   let emojiKeyboardHeight = 435;
 
   if (emojiKeyboard) {
     const { width, height } = emojiKeyboard.getBoundingClientRect();
     emojiKeyboardWidth = width;
     emojiKeyboardHeight = height;
   }
 
   const {
     top: containerTop,
     left: containerLeft,
     right: containerRight,
     bottom: containerBottom,
   } = appContainerPositionInfo;
 
   const padding = 16;
 
   const canBeDisplayedOnRight =
     tooltipAnchorX + tooltipWidth + emojiKeyboardWidth <= containerRight;
 
   const canBeDisplayedOnLeft =
     tooltipAnchorX - emojiKeyboardWidth >= containerLeft;
 
   const canBeDisplayedOnTop =
     tooltipAnchorY - emojiKeyboardHeight - padding >= containerTop;
 
   const canBeDisplayedOnBottom =
     tooltipAnchorY + tooltipHeight + emojiKeyboardHeight + padding <=
     containerBottom;
 
   const emojiKeyboardOverflowTop =
     containerTop - (tooltipAnchorY + tooltipHeight - emojiKeyboardHeight);
 
   const emojiKeyboardOverflowTopCorrection =
     emojiKeyboardOverflowTop > 0 ? -emojiKeyboardOverflowTop - padding : 0;
 
   const emojiKeyboardOverflowRight =
     tooltipAnchorX + emojiKeyboardWidth - containerRight;
 
   const emojiKeyboardOverflowRightCorrection =
     emojiKeyboardOverflowRight > 0 ? -emojiKeyboardOverflowRight - padding : 0;
 
   if (alignment === 'left' && canBeDisplayedOnRight) {
     return {
       left: tooltipWidth,
       bottom: emojiKeyboardOverflowTopCorrection,
     };
   }
 
   if (alignment === 'right' && canBeDisplayedOnLeft) {
     return {
       left: -emojiKeyboardWidth,
       bottom: emojiKeyboardOverflowTopCorrection,
     };
   }
 
   if (canBeDisplayedOnTop) {
     return {
       bottom: tooltipHeight + padding,
       left: emojiKeyboardOverflowRightCorrection,
     };
   }
 
   if (canBeDisplayedOnBottom) {
     return {
       bottom: -emojiKeyboardHeight - padding,
       left: emojiKeyboardOverflowRightCorrection,
     };
   }
 
   return {
     left: alignment === 'left' ? -emojiKeyboardWidth : tooltipWidth,
     bottom: emojiKeyboardOverflowTopCorrection,
   };
 }
 
 export { useSendReaction, getEmojiKeyboardPosition };
diff --git a/web/input/input-state-container.react.js b/web/input/input-state-container.react.js
index 84eaaef5f..ba627865c 100644
--- a/web/input/input-state-container.react.js
+++ b/web/input/input-state-container.react.js
@@ -1,1767 +1,1777 @@
 // @flow
 
 import invariant from 'invariant';
 import _groupBy from 'lodash/fp/groupBy.js';
 import _keyBy from 'lodash/fp/keyBy.js';
 import _omit from 'lodash/fp/omit.js';
 import _partition from 'lodash/fp/partition.js';
 import _sortBy from 'lodash/fp/sortBy.js';
 import _memoize from 'lodash/memoize.js';
 import * as React from 'react';
 import { createSelector } from 'reselect';
 
 import {
   createLocalMessageActionType,
   sendMultimediaMessageActionTypes,
   sendTextMessageActionTypes,
 } from 'lib/actions/message-actions.js';
 import { queueReportsActionType } from 'lib/actions/report-actions.js';
 import { useNewThinThread } from 'lib/actions/thread-actions.js';
 import {
   type BlobServiceUploadAction,
   type DeleteUploadInput,
   type MultimediaUploadCallbacks,
   type MultimediaUploadExtras,
   updateMultimediaMessageMediaActionType,
   uploadMultimedia,
   useBlobServiceUpload,
   useDeleteUpload,
 } from 'lib/actions/upload-actions.js';
 import {
   type PushModal,
   useModalContext,
 } from 'lib/components/modal-provider.react.js';
 import blobService from 'lib/facts/blob-service.js';
 import commStaffCommunity from 'lib/facts/comm-staff-community.js';
 import {
   type SendMultimediaMessagePayload,
   useInputStateContainerSendMultimediaMessage,
   useInputStateContainerSendTextMessage,
 } from 'lib/hooks/input-state-container-hooks.js';
 import { useNewThickThread } from 'lib/hooks/thread-hooks.js';
 import { useLegacyAshoatKeyserverCall } from 'lib/keyserver-conn/legacy-keyserver-call.js';
 import { getNextLocalUploadID } from 'lib/media/media-utils.js';
 import { pendingToRealizedThreadIDsSelector } from 'lib/selectors/thread-selectors.js';
 import { IdentityClientContext } from 'lib/shared/identity-client-context.js';
 import type { IdentityClientContextType } from 'lib/shared/identity-client-context.js';
 import {
   createMediaMessageInfo,
   localIDPrefix,
   useMessageCreationSideEffectsFunc,
   getNextLocalID,
 } from 'lib/shared/message-utils.js';
 import type { CreationSideEffectsFunc } from 'lib/shared/messages/message-spec.js';
 import { createRealThreadFromPendingThread } from 'lib/shared/thread-actions-utils.js';
 import {
   draftKeyFromThreadID,
   patchThreadInfoToIncludeMentionedMembersOfParent,
   threadInfoInsideCommunity,
   threadIsPending,
   threadIsPendingSidebar,
 } from 'lib/shared/thread-utils.js';
 import type { CalendarQuery } from 'lib/types/entry-types.js';
 import type {
   MediaMission,
   MediaMissionFailure,
   MediaMissionResult,
   MediaMissionStep,
   UploadMultimediaResult,
 } from 'lib/types/media-types.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import {
   type RawMessageInfo,
   type RawMultimediaMessageInfo,
   type SendMessagePayload,
 } from 'lib/types/message-types.js';
 import type { RawImagesMessageInfo } from 'lib/types/messages/images.js';
 import type { RawMediaMessageInfo } from 'lib/types/messages/media.js';
 import type { RawTextMessageInfo } from 'lib/types/messages/text.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
 import type { Dispatch } from 'lib/types/redux-types.js';
 import { reportTypes } from 'lib/types/report-types.js';
 import {
   threadTypeIsSidebar,
   threadTypeIsThick,
 } from 'lib/types/thread-types-enum.js';
 import type { ThreadType } from 'lib/types/thread-types-enum.js';
 import {
   type ClientNewThinThreadRequest,
   type NewThreadResult,
   type NewThickThreadRequest,
 } from 'lib/types/thread-types.js';
 import {
   blobHashFromBlobServiceURI,
   isBlobServiceURI,
   makeBlobServiceEndpointURL,
 } from 'lib/utils/blob-service.js';
 import { getConfig } from 'lib/utils/config.js';
-import { cloneError, getMessageForException } from 'lib/utils/errors.js';
+import { getMessageForException, SendMessageError } from 'lib/utils/errors.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/redux-promise-utils.js';
 import { useDispatch } from 'lib/utils/redux-utils.js';
 import { generateReportID } from 'lib/utils/report-utils.js';
 import { createDefaultHTTPRequestHeaders } from 'lib/utils/services-utils.js';
 
 import {
   type BaseInputState,
   type InputState,
   InputStateContext,
   type PendingMultimediaUpload,
   type TypeaheadInputState,
   type TypeaheadState,
 } from './input-state.js';
 import { encryptFile } from '../media/encryption-utils.js';
 import { generateThumbHash } from '../media/image-utils.js';
 import {
   preloadImage,
   preloadMediaResource,
   validateFile,
 } from '../media/media-utils.js';
 import InvalidUploadModal from '../modals/chat/invalid-upload.react.js';
 import { updateNavInfoActionType } from '../redux/action-types.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { nonThreadCalendarQuery } from '../selectors/nav-selectors.js';
 
 type CombinedInputState = {
   +inputBaseState: BaseInputState,
   +typeaheadState: TypeaheadInputState,
 };
 
 type BaseProps = {
   +children: React.Node,
 };
 type Props = {
   ...BaseProps,
   +activeChatThreadID: ?string,
   +drafts: { +[key: string]: string },
   +viewerID: ?string,
   +messageStoreMessages: { +[id: string]: RawMessageInfo },
   +pendingRealizedThreadIDs: $ReadOnlyMap<string, string>,
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
   +calendarQuery: () => CalendarQuery,
   +uploadMultimedia: (
     multimedia: Object,
     extras: MultimediaUploadExtras,
     callbacks: MultimediaUploadCallbacks,
   ) => Promise<UploadMultimediaResult>,
   +blobServiceUpload: BlobServiceUploadAction,
   +deleteUpload: (input: DeleteUploadInput) => Promise<void>,
   +sendMultimediaMessage: (
     messageInfo: RawMultimediaMessageInfo,
     sidebarCreation: boolean,
     isLegacy: boolean,
   ) => Promise<SendMultimediaMessagePayload>,
   +sendTextMessage: (
     messageInfo: RawTextMessageInfo,
     threadInfo: ThreadInfo,
     parentThreadInfo: ?ThreadInfo,
     sidebarCreation: boolean,
   ) => Promise<SendMessagePayload>,
   +newThinThread: (
     request: ClientNewThinThreadRequest,
   ) => Promise<NewThreadResult>,
   +newThickThread: (request: NewThickThreadRequest) => Promise<string>,
   +pushModal: PushModal,
   +sendCallbacks: $ReadOnlyArray<() => mixed>,
   +registerSendCallback: (() => mixed) => void,
   +unregisterSendCallback: (() => mixed) => void,
   +textMessageCreationSideEffectsFunc: CreationSideEffectsFunc<RawTextMessageInfo>,
   +identityContext: ?IdentityClientContextType,
 };
 type WritableState = {
   pendingUploads: {
     [threadID: string]: { [localUploadID: string]: PendingMultimediaUpload },
   },
   textCursorPositions: { [threadID: string]: number },
   typeaheadState: TypeaheadState,
 };
 type State = $ReadOnly<WritableState>;
 
 type PropsAndState = {
   ...Props,
   ...State,
 };
 
 class InputStateContainer extends React.PureComponent<Props, State> {
   state: State = {
     pendingUploads: {},
     textCursorPositions: {},
     typeaheadState: {
       canBeVisible: false,
       keepUpdatingThreadMembers: true,
       frozenUserMentionsCandidates: [],
       frozenChatMentionsCandidates: {},
       moveChoiceUp: null,
       moveChoiceDown: null,
       close: null,
       accept: null,
     },
   };
   replyCallbacks: Array<(message: string) => void> = [];
   pendingThreadCreations: Map<
     string,
     Promise<{
       +threadID: string,
       +threadType: ThreadType,
     }>,
   > = new Map<
     string,
     Promise<{
       +threadID: string,
       +threadType: ThreadType,
     }>,
   >();
   // TODO: flip the switch
   // Note that this enables Blob service for encrypted media only
   useBlobServiceUploads = false;
 
   // When the user sends a multimedia message that triggers the creation of a
   // sidebar, the sidebar gets created right away, but the message needs to wait
   // for the uploads to complete before sending. We use this Set to track the
   // message localIDs that need sidebarCreation: true.
   pendingSidebarCreationMessageLocalIDs: Set<string> = new Set<string>();
 
   static reassignToRealizedThreads<T>(
     state: { +[threadID: string]: T },
     props: Props,
   ): ?{ [threadID: string]: T } {
     const newState: { [string]: T } = {};
     let updated = false;
     for (const threadID in state) {
       const newThreadID =
         props.pendingRealizedThreadIDs.get(threadID) ?? threadID;
       if (newThreadID !== threadID) {
         updated = true;
       }
       newState[newThreadID] = state[threadID];
     }
     return updated ? newState : null;
   }
 
   static getDerivedStateFromProps(props: Props, state: State): ?Partial<State> {
     const pendingUploads = InputStateContainer.reassignToRealizedThreads(
       state.pendingUploads,
       props,
     );
     const textCursorPositions = InputStateContainer.reassignToRealizedThreads(
       state.textCursorPositions,
       props,
     );
 
     if (!pendingUploads && !textCursorPositions) {
       return null;
     }
 
     const stateUpdate: Partial<WritableState> = {};
     if (pendingUploads) {
       stateUpdate.pendingUploads = pendingUploads;
     }
     if (textCursorPositions) {
       stateUpdate.textCursorPositions = textCursorPositions;
     }
     return stateUpdate;
   }
 
   static completedMessageIDs(state: State): Set<string> {
     const completed = new Map<string, boolean>();
     for (const threadID in state.pendingUploads) {
       const pendingUploads = state.pendingUploads[threadID];
       for (const localUploadID in pendingUploads) {
         const upload = pendingUploads[localUploadID];
         const { messageID, canBeSent, failed } = upload;
         if (!messageID || !messageID.startsWith(localIDPrefix)) {
           continue;
         }
         if (!canBeSent || failed) {
           completed.set(messageID, false);
           continue;
         }
         if (completed.get(messageID) === undefined) {
           completed.set(messageID, true);
         }
       }
     }
     const messageIDs = new Set<string>();
     for (const [messageID, isCompleted] of completed) {
       if (isCompleted) {
         messageIDs.add(messageID);
       }
     }
     return messageIDs;
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     if (this.props.viewerID !== prevProps.viewerID) {
       this.setState({ pendingUploads: {} });
       return;
     }
 
     const previouslyAssignedMessageIDs = new Set<string>();
     for (const threadID in prevState.pendingUploads) {
       const pendingUploads = prevState.pendingUploads[threadID];
       for (const localUploadID in pendingUploads) {
         const { messageID } = pendingUploads[localUploadID];
         if (messageID) {
           previouslyAssignedMessageIDs.add(messageID);
         }
       }
     }
 
     const newlyAssignedUploads = new Map<
       string,
       {
         +threadID: string,
         +shouldEncrypt: boolean,
         +uploads: PendingMultimediaUpload[],
       },
     >();
     for (const threadID in this.state.pendingUploads) {
       const pendingUploads = this.state.pendingUploads[threadID];
       for (const localUploadID in pendingUploads) {
         const upload = pendingUploads[localUploadID];
         const { messageID } = upload;
         if (
           !messageID ||
           !messageID.startsWith(localIDPrefix) ||
           previouslyAssignedMessageIDs.has(messageID)
         ) {
           continue;
         }
         const { shouldEncrypt } = upload;
         let assignedUploads = newlyAssignedUploads.get(messageID);
         if (!assignedUploads) {
           assignedUploads = { threadID, shouldEncrypt, uploads: [] };
           newlyAssignedUploads.set(messageID, assignedUploads);
         }
         if (shouldEncrypt !== assignedUploads.shouldEncrypt) {
           console.warn(
             `skipping upload ${localUploadID} ` +
               "because shouldEncrypt doesn't match",
           );
           continue;
         }
         assignedUploads.uploads.push(upload);
       }
     }
 
     const newMessageInfos = new Map<string, RawMultimediaMessageInfo>();
     for (const [messageID, assignedUploads] of newlyAssignedUploads) {
       const { uploads, threadID, shouldEncrypt } = assignedUploads;
       const creatorID = this.props.viewerID;
       invariant(creatorID, 'need viewer ID in order to send a message');
       const media = uploads.map(
         ({
           localID,
           serverID,
           uri,
           mediaType,
           dimensions,
           encryptionKey,
           thumbHash,
         }) => {
           // We can get into this state where dimensions are null if the user is
           // uploading a file type that the browser can't render. In that case
           // we fake the dimensions here while we wait for the server to tell us
           // the true dimensions.
           const shimmedDimensions = dimensions ?? { height: 0, width: 0 };
           invariant(
             mediaType === 'photo' || mediaType === 'encrypted_photo',
             "web InputStateContainer can't handle video",
           );
           if (
             mediaType !== 'encrypted_photo' &&
             mediaType !== 'encrypted_video'
           ) {
             return {
               id: serverID ? serverID : localID,
               uri,
               type: 'photo',
               dimensions: shimmedDimensions,
               thumbHash,
             };
           }
           invariant(
             encryptionKey,
             'encrypted media must have an encryption key',
           );
           return {
             id: serverID ? serverID : localID,
             blobURI: uri,
             type: 'encrypted_photo',
             encryptionKey,
             dimensions: shimmedDimensions,
             thumbHash,
           };
         },
       );
       const messageInfo = createMediaMessageInfo(
         {
           localID: messageID,
           threadID,
           creatorID,
           media,
         },
         { forceMultimediaMessageType: shouldEncrypt },
       );
       newMessageInfos.set(messageID, messageInfo);
     }
 
     const currentlyCompleted = InputStateContainer.completedMessageIDs(
       this.state,
     );
     const previouslyCompleted =
       InputStateContainer.completedMessageIDs(prevState);
     for (const messageID of currentlyCompleted) {
       if (previouslyCompleted.has(messageID)) {
         continue;
       }
       let rawMessageInfo = newMessageInfos.get(messageID);
       if (rawMessageInfo) {
         newMessageInfos.delete(messageID);
       } else {
         rawMessageInfo = this.getRawMultimediaMessageInfo(messageID);
       }
       void this.sendMultimediaMessage(rawMessageInfo);
     }
 
     for (const [, messageInfo] of newMessageInfos) {
       this.props.dispatch({
         type: createLocalMessageActionType,
         payload: messageInfo,
       });
     }
   }
 
   getRawMultimediaMessageInfo(
     localMessageID: string,
   ): RawMultimediaMessageInfo {
     const rawMessageInfo = this.props.messageStoreMessages[localMessageID];
     invariant(rawMessageInfo, `rawMessageInfo ${localMessageID} should exist`);
     invariant(
       rawMessageInfo.type === messageTypes.IMAGES ||
         rawMessageInfo.type === messageTypes.MULTIMEDIA,
       `rawMessageInfo ${localMessageID} should be multimedia`,
     );
     return rawMessageInfo;
   }
 
   shouldEncryptMedia(threadInfo: ThreadInfo): boolean {
     return (
       threadTypeIsThick(threadInfo.type) ||
       threadInfoInsideCommunity(threadInfo, commStaffCommunity.id)
     );
   }
 
   async sendMultimediaMessage(
     messageInfo: RawMultimediaMessageInfo,
   ): Promise<void> {
     if (!threadIsPending(messageInfo.threadID)) {
       void this.props.dispatchActionPromise(
         sendMultimediaMessageActionTypes,
         this.sendMultimediaMessageAction(messageInfo),
         undefined,
         messageInfo,
       );
       return;
     }
 
     this.props.dispatch({
       type: sendMultimediaMessageActionTypes.started,
       payload: messageInfo,
     });
 
     let newThreadID = null;
     try {
       const threadCreationPromise = this.pendingThreadCreations.get(
         messageInfo.threadID,
       );
       if (!threadCreationPromise) {
         // When we create or retry multimedia message, we add a promise to
         // pendingThreadCreations map. This promise can be removed in
         // sendMultimediaMessage and sendTextMessage methods. When any of these
         // method remove the promise, it has to be settled. If the promise was
         // fulfilled, this method would be called with realized thread, so we
         // can conclude that the promise was rejected. We don't have enough info
         // here to retry the thread creation, but we can mark the message as
         // failed. Then the retry will be possible and promise will be created
         // again.
         throw new Error('Thread creation failed');
       }
       const result = await threadCreationPromise;
       newThreadID = result.threadID;
     } catch (e) {
-      const copy = cloneError(e);
-      copy.localID = messageInfo.localID;
-      copy.threadID = messageInfo.threadID;
+      const exceptionMessage = getMessageForException(e) ?? '';
+      const payload = new SendMessageError(
+        `Exception when creating thread: ${exceptionMessage}`,
+        messageInfo.localID ?? '',
+        messageInfo.threadID,
+      );
       this.props.dispatch({
         type: sendMultimediaMessageActionTypes.failed,
-        payload: copy,
+        payload,
         error: true,
       });
       return;
     } finally {
       this.pendingThreadCreations.delete(messageInfo.threadID);
     }
 
     // While the thread was being created, the image preload may have completed,
     // and we might have a finalized URI now. So we fetch from Redux again
     const { localID } = messageInfo;
     invariant(
       localID !== null && localID !== undefined,
       'localID should exist for locally-created RawMessageInfo',
     );
     const latestMessageInfo = this.getRawMultimediaMessageInfo(localID);
 
     // Conditional is necessary for Flow
     let newMessageInfo;
     if (latestMessageInfo.type === messageTypes.MULTIMEDIA) {
       newMessageInfo = {
         ...latestMessageInfo,
         threadID: newThreadID,
         time: Date.now(),
       };
     } else {
       newMessageInfo = {
         ...latestMessageInfo,
         threadID: newThreadID,
         time: Date.now(),
       };
     }
 
     void this.props.dispatchActionPromise(
       sendMultimediaMessageActionTypes,
       this.sendMultimediaMessageAction(newMessageInfo),
       undefined,
       newMessageInfo,
     );
   }
 
   async sendMultimediaMessageAction(
     messageInfo: RawMultimediaMessageInfo,
   ): Promise<SendMessagePayload> {
     const { localID, threadID } = messageInfo;
     invariant(
       localID !== null && localID !== undefined,
       'localID should be set',
     );
     const sidebarCreation =
       this.pendingSidebarCreationMessageLocalIDs.has(localID);
     try {
       const { result, mediaIDUpdates } = await this.props.sendMultimediaMessage(
         messageInfo,
         sidebarCreation,
         true,
       );
       this.pendingSidebarCreationMessageLocalIDs.delete(localID);
       this.setState(prevState => {
         const newThreadID = this.getRealizedOrPendingThreadID(threadID);
         const prevUploads = prevState.pendingUploads[newThreadID];
         const newUploads: { [string]: PendingMultimediaUpload } = {};
         for (const localUploadID in prevUploads) {
           const upload = prevUploads[localUploadID];
           if (upload.messageID !== localID) {
             newUploads[localUploadID] = upload;
           } else if (!upload.uriIsReal) {
             const { serverID } = upload;
             let newServerID = serverID;
             if (serverID && mediaIDUpdates?.[serverID]) {
               newServerID = mediaIDUpdates[serverID].id;
             }
             newUploads[localUploadID] = {
               ...upload,
               messageID: result.serverID,
               serverID: newServerID,
             };
           }
         }
         return {
           pendingUploads: {
             ...prevState.pendingUploads,
             [newThreadID]: newUploads,
           },
         };
       });
       return result;
     } catch (e) {
-      const copy = cloneError(e);
-      copy.localID = localID;
-      copy.threadID = threadID;
-      throw copy;
+      const exceptionMessage = getMessageForException(e) ?? '';
+      throw new SendMessageError(
+        `Exception while sending multimedia message: ${exceptionMessage}`,
+        localID,
+        threadID,
+      );
     }
   }
 
   startThreadCreation(threadInfo: ThreadInfo): Promise<{
     +threadID: string,
     +threadType: ThreadType,
   }> {
     if (!threadIsPending(threadInfo.id)) {
       return Promise.resolve({
         threadID: threadInfo.id,
         threadType: threadInfo.type,
       });
     }
     let threadCreationPromise = this.pendingThreadCreations.get(threadInfo.id);
     if (!threadCreationPromise) {
       const calendarQuery = this.props.calendarQuery();
       threadCreationPromise = createRealThreadFromPendingThread({
         threadInfo,
         dispatchActionPromise: this.props.dispatchActionPromise,
         createNewThinThread: this.props.newThinThread,
         createNewThickThread: this.props.newThickThread,
         sourceMessageID: threadInfo.sourceMessageID,
         viewerID: this.props.viewerID,
         calendarQuery,
       });
       this.pendingThreadCreations.set(threadInfo.id, threadCreationPromise);
     }
     return threadCreationPromise;
   }
 
   inputBaseStateSelector: (?string) => PropsAndState => BaseInputState =
     _memoize(threadID =>
       createSelector(
         (propsAndState: PropsAndState) =>
           threadID ? propsAndState.pendingUploads[threadID] : null,
         (propsAndState: PropsAndState) =>
           threadID
             ? propsAndState.drafts[draftKeyFromThreadID(threadID)]
             : null,
         (propsAndState: PropsAndState) =>
           threadID ? propsAndState.textCursorPositions[threadID] : null,
         (
           pendingUploads: ?{ [localUploadID: string]: PendingMultimediaUpload },
           draft: ?string,
           textCursorPosition: ?number,
         ) => {
           let threadPendingUploads: $ReadOnlyArray<PendingMultimediaUpload> =
             [];
           const assignedUploads: {
             [string]: $ReadOnlyArray<PendingMultimediaUpload>,
           } = {};
           if (pendingUploads) {
             const [uploadsWithMessageIDs, uploadsWithoutMessageIDs] =
               _partition('messageID')(pendingUploads);
             threadPendingUploads = _sortBy('localID')(uploadsWithoutMessageIDs);
             const threadAssignedUploads = _groupBy('messageID')(
               uploadsWithMessageIDs,
             );
             for (const messageID in threadAssignedUploads) {
               // lodash libdefs don't return $ReadOnlyArray
               assignedUploads[messageID] = [
                 ...threadAssignedUploads[messageID],
               ];
             }
           }
           return ({
             pendingUploads: threadPendingUploads,
             assignedUploads,
             draft: draft ?? '',
             textCursorPosition: textCursorPosition ?? 0,
             appendFiles: (
               threadInfo: ThreadInfo,
               files: $ReadOnlyArray<File>,
             ) => this.appendFiles(threadInfo, files),
             cancelPendingUpload: this.cancelPendingUpload,
             sendTextMessage: (
               messageInfo: RawTextMessageInfo,
               threadInfo: ThreadInfo,
               parentThreadInfo: ?ThreadInfo,
             ) =>
               this.sendTextMessage(messageInfo, threadInfo, parentThreadInfo),
             createMultimediaMessage: (threadInfo: ThreadInfo) =>
               this.createMultimediaMessage(threadInfo),
             setDraft: (newDraft: string) => this.setDraft(threadID, newDraft),
             setTextCursorPosition: (newPosition: number) =>
               this.setTextCursorPosition(threadID, newPosition),
             messageHasUploadFailure: (localMessageID: string) =>
               this.messageHasUploadFailure(assignedUploads[localMessageID]),
             retryMultimediaMessage: (
               localMessageID: string,
               threadInfo: ThreadInfo,
             ) =>
               this.retryMultimediaMessage(
                 localMessageID,
                 threadInfo,
                 assignedUploads[localMessageID],
               ),
             addReply: (message: string) => this.addReply(message),
             addReplyListener: this.addReplyListener,
             removeReplyListener: this.removeReplyListener,
             registerSendCallback: this.props.registerSendCallback,
             unregisterSendCallback: this.props.unregisterSendCallback,
           }: BaseInputState);
         },
       ),
     );
 
   typeaheadStateSelector: PropsAndState => TypeaheadInputState = createSelector(
     (propsAndState: PropsAndState) => propsAndState.typeaheadState,
     (typeaheadState: TypeaheadState) => ({
       typeaheadState,
       setTypeaheadState: this.setTypeaheadState,
     }),
   );
 
   inputStateSelector: CombinedInputState => InputState = createSelector(
     (state: CombinedInputState) => state.inputBaseState,
     (state: CombinedInputState) => state.typeaheadState,
     (inputBaseState: BaseInputState, typeaheadState: TypeaheadInputState) => ({
       ...inputBaseState,
       ...typeaheadState,
     }),
   );
 
   getRealizedOrPendingThreadID(threadID: string): string {
     return this.props.pendingRealizedThreadIDs.get(threadID) ?? threadID;
   }
 
   async appendFiles(
     threadInfo: ThreadInfo,
     files: $ReadOnlyArray<File>,
   ): Promise<boolean> {
     const selectionTime = Date.now();
     const { pushModal } = this.props;
 
     const appendResults = await Promise.all(
       files.map(file => this.appendFile(threadInfo, file, selectionTime)),
     );
 
     if (appendResults.some(({ result }) => !result.success)) {
       pushModal(<InvalidUploadModal />);
 
       const time = Date.now() - selectionTime;
       const reports = [];
       for (const appendResult of appendResults) {
         const { steps } = appendResult;
         let { result } = appendResult;
         let uploadLocalID;
         if (result.success) {
           uploadLocalID = result.pendingUpload.localID;
           result = { success: false, reason: 'web_sibling_validation_failed' };
         }
         const mediaMission = { steps, result, userTime: time, totalTime: time };
         reports.push({ mediaMission, uploadLocalID });
       }
       this.queueMediaMissionReports(reports);
 
       return false;
     }
 
     const newUploads = appendResults.map(({ result }) => {
       invariant(result.success, 'any failed validation should be caught above');
       return result.pendingUpload;
     });
 
     const newUploadsObject = _keyBy('localID')(newUploads);
     this.setState(
       prevState => {
         const newThreadID = this.getRealizedOrPendingThreadID(threadInfo.id);
         const prevUploads = prevState.pendingUploads[newThreadID];
         const mergedUploads = prevUploads
           ? { ...prevUploads, ...newUploadsObject }
           : newUploadsObject;
         return {
           pendingUploads: {
             ...prevState.pendingUploads,
             [newThreadID]: mergedUploads,
           },
         };
       },
       () => this.uploadFiles(threadInfo, newUploads),
     );
     return true;
   }
 
   async appendFile(
     threadInfo: ThreadInfo,
     file: File,
     selectTime: number,
   ): Promise<{
     steps: $ReadOnlyArray<MediaMissionStep>,
     result:
       | MediaMissionFailure
       | { success: true, pendingUpload: PendingMultimediaUpload },
   }> {
     const steps: MediaMissionStep[] = [
       {
         step: 'web_selection',
         filename: file.name,
         size: file.size,
         mime: file.type,
         selectTime,
       },
     ];
 
     let response;
     const validationStart = Date.now();
     try {
       response = await validateFile(file);
     } catch (e) {
       return {
         steps,
         result: {
           success: false,
           reason: 'processing_exception',
           time: Date.now() - validationStart,
           exceptionMessage: getMessageForException(e),
         },
       };
     }
     const { steps: validationSteps, result } = response;
     steps.push(...validationSteps);
     if (!result.success) {
       return { steps, result };
     }
     const { uri, file: fixedFile, mediaType, dimensions } = result;
 
     const shouldEncrypt = this.shouldEncryptMedia(threadInfo);
 
     let encryptionResult;
     if (shouldEncrypt) {
       let encryptionResponse;
       const encryptionStart = Date.now();
       try {
         encryptionResponse = await encryptFile(fixedFile);
       } catch (e) {
         return {
           steps,
           result: {
             success: false,
             reason: 'encryption_exception',
             time: Date.now() - encryptionStart,
             exceptionMessage: getMessageForException(e),
           },
         };
       }
       steps.push(...encryptionResponse.steps);
       encryptionResult = encryptionResponse.result;
     }
     if (encryptionResult && !encryptionResult.success) {
       return { steps, result: encryptionResult };
     }
 
     const { steps: thumbHashSteps, result: thumbHashResult } =
       await generateThumbHash(fixedFile, encryptionResult?.encryptionKey);
     const thumbHash = thumbHashResult.success
       ? thumbHashResult.thumbHash
       : null;
     steps.push(...thumbHashSteps);
 
     return {
       steps,
       result: {
         success: true,
         pendingUpload: {
           localID: getNextLocalUploadID(),
           serverID: null,
           messageID: null,
           failed: false,
           file: encryptionResult?.file ?? fixedFile,
           mediaType: encryptionResult ? 'encrypted_photo' : mediaType,
           dimensions,
           uri: encryptionResult?.uri ?? uri,
           loop: false,
           uriIsReal: false,
           canBeSent: false,
           blobHolder: null,
           blobHash: encryptionResult?.sha256Hash,
           encryptionKey: encryptionResult?.encryptionKey,
           thumbHash,
           progressPercent: 0,
           abort: null,
           steps,
           selectTime,
           shouldEncrypt,
         },
       },
     };
   }
 
   uploadFiles(
     threadInfo: ThreadInfo,
     uploads: $ReadOnlyArray<PendingMultimediaUpload>,
   ): Promise<mixed> {
     return Promise.all(
       uploads.map(upload => this.uploadFile(threadInfo, upload)),
     );
   }
 
   async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) {
     const { selectTime, localID, encryptionKey } = upload;
     const threadID = threadInfo.id;
     const isThickThread = threadTypeIsThick(threadInfo.type);
     const isEncrypted =
       !!encryptionKey &&
       (upload.mediaType === 'encrypted_photo' ||
         upload.mediaType === 'encrypted_video');
 
     const steps = [...upload.steps];
     let userTime;
 
     const { identityContext } = this.props;
     invariant(identityContext, 'Identity context should be set');
 
     const sendReport = (missionResult: MediaMissionResult) => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadID);
       const latestUpload = this.state.pendingUploads[newThreadID][localID];
       invariant(
         latestUpload,
         `pendingUpload ${localID} for ${newThreadID} missing in sendReport`,
       );
       const { serverID, messageID } = latestUpload;
       const totalTime = Date.now() - selectTime;
       userTime = userTime ? userTime : totalTime;
       const mission = { steps, result: missionResult, totalTime, userTime };
       this.queueMediaMissionReports([
         {
           mediaMission: mission,
           uploadLocalID: localID,
           uploadServerID: serverID,
           messageLocalID: messageID,
         },
       ]);
     };
 
     let uploadResult, uploadExceptionMessage;
     const uploadStart = Date.now();
     try {
       const callbacks = {
         onProgress: (percent: number) =>
           this.setProgress(threadID, localID, percent),
         abortHandler: (abort: () => void) =>
           this.handleAbortCallback(threadID, localID, abort),
       };
       const useBlobService = isThickThread || this.useBlobServiceUploads;
       if (
         useBlobService &&
         (upload.mediaType === 'encrypted_photo' ||
           upload.mediaType === 'encrypted_video')
       ) {
         const { blobHash, dimensions, thumbHash } = upload;
         invariant(
           encryptionKey && blobHash && dimensions,
           'incomplete encrypted upload',
         );
 
         uploadResult = await this.props.blobServiceUpload({
           uploadInput: {
             blobInput: {
               type: 'file',
               file: upload.file,
             },
             blobHash,
             encryptionKey,
             dimensions,
             loop: false,
             thumbHash,
           },
           keyserverOrThreadID: isThickThread ? null : threadID,
           callbacks,
         });
       } else {
         let uploadExtras = {
           ...upload.dimensions,
           loop: false,
           thumbHash: upload.thumbHash,
         };
         if (encryptionKey) {
           uploadExtras = { ...uploadExtras, encryptionKey };
         }
         uploadResult = await this.props.uploadMultimedia(
           upload.file,
           uploadExtras,
           callbacks,
         );
       }
     } catch (e) {
       uploadExceptionMessage = getMessageForException(e);
       this.handleUploadFailure(threadID, localID);
     }
     userTime = Date.now() - selectTime;
     steps.push({
       step: 'upload',
       success: !!uploadResult,
       exceptionMessage: uploadExceptionMessage,
       time: Date.now() - uploadStart,
       inputFilename: upload.file.name,
       outputMediaType: uploadResult && uploadResult.mediaType,
       outputURI: uploadResult && uploadResult.uri,
       outputDimensions: uploadResult && uploadResult.dimensions,
       outputLoop: uploadResult && uploadResult.loop,
     });
     if (!uploadResult) {
       sendReport({
         success: false,
         reason: 'http_upload_failed',
         exceptionMessage: uploadExceptionMessage,
       });
       return;
     }
     const result = uploadResult;
     const outputMediaType = isEncrypted ? 'encrypted_photo' : result.mediaType;
 
     const successThreadID = this.getRealizedOrPendingThreadID(threadID);
     const uploadAfterSuccess =
       this.state.pendingUploads[successThreadID][localID];
     invariant(
       uploadAfterSuccess,
       `pendingUpload ${localID}/${result.id} for ${successThreadID} missing ` +
         `after upload`,
     );
     if (uploadAfterSuccess.messageID) {
       this.props.dispatch({
         type: updateMultimediaMessageMediaActionType,
         payload: {
           messageID: uploadAfterSuccess.messageID,
           currentMediaID: localID,
           mediaUpdate: {
             id: result.id,
           },
         },
       });
     }
 
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadID);
       const uploads = prevState.pendingUploads[newThreadID];
       const currentUpload = uploads[localID];
       invariant(
         currentUpload,
         `pendingUpload ${localID}/${result.id} for ${newThreadID} ` +
           `missing while assigning serverID`,
       );
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [newThreadID]: {
             ...uploads,
             [localID]: {
               ...currentUpload,
               serverID: result.id,
               blobHolder: result.blobHolder,
               abort: null,
               // For thin threads we can send message right after serverID
               // is present, but for thick threads we need to wait until
               // a "real" Blob URI is assigned to the message.
               canBeSent: !isThickThread,
             },
           },
         },
       };
     });
 
     if (encryptionKey) {
       const authMetadata = await identityContext.getAuthMetadata();
       const { steps: preloadSteps } = await preloadMediaResource(
         result.uri,
         authMetadata,
       );
       steps.push(...preloadSteps);
     } else {
       const { steps: preloadSteps } = await preloadImage(result.uri);
       steps.push(...preloadSteps);
     }
     sendReport({ success: true });
 
     const preloadThreadID = this.getRealizedOrPendingThreadID(threadID);
     const uploadAfterPreload =
       this.state.pendingUploads[preloadThreadID][localID];
     invariant(
       uploadAfterPreload,
       `pendingUpload ${localID}/${result.id} for ${preloadThreadID} missing ` +
         `after preload`,
     );
     if (uploadAfterPreload.messageID) {
       const { mediaType, uri, dimensions } = result;
       const { thumbHash } = upload;
       let mediaUpdate = {
         dimensions,
         ...(thumbHash ? { thumbHash } : undefined),
       };
       if (!isEncrypted) {
         mediaUpdate = {
           ...mediaUpdate,
           type: mediaType,
           uri,
         };
       } else {
         mediaUpdate = {
           ...mediaUpdate,
           type: outputMediaType,
           blobURI: uri,
           encryptionKey,
         };
       }
       this.props.dispatch({
         type: updateMultimediaMessageMediaActionType,
         payload: {
           messageID: uploadAfterPreload.messageID,
           currentMediaID: result.id ?? uploadAfterPreload.localID,
           mediaUpdate,
         },
       });
     }
 
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadID);
       const uploads = prevState.pendingUploads[newThreadID];
       const currentUpload = uploads[localID];
       invariant(
         currentUpload,
         `pendingUpload ${localID}/${result.id} for ${newThreadID} ` +
           `missing while assigning URI`,
       );
       const { messageID } = currentUpload;
       if (messageID && !messageID.startsWith(localIDPrefix)) {
         const newPendingUploads = _omit([localID])(uploads);
         return {
           pendingUploads: {
             ...prevState.pendingUploads,
             [newThreadID]: newPendingUploads,
           },
         };
       }
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [newThreadID]: {
             ...uploads,
             [localID]: {
               ...currentUpload,
               uri: result.uri,
               mediaType: outputMediaType,
               dimensions: result.dimensions,
               loop: result.loop,
               uriIsReal: true,
               canBeSent: true,
             },
           },
         },
       };
     });
   }
 
   handleAbortCallback(
     threadID: string,
     localUploadID: string,
     abort: () => void,
   ) {
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadID);
       const uploads = prevState.pendingUploads[newThreadID];
       const upload = uploads[localUploadID];
       if (!upload) {
         // The upload has been cancelled before we were even handed the
         // abort function. We should immediately abort.
         abort();
       }
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [newThreadID]: {
             ...uploads,
             [localUploadID]: {
               ...upload,
               abort,
             },
           },
         },
       };
     });
   }
 
   handleUploadFailure(threadID: string, localUploadID: string) {
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadID);
       const uploads = prevState.pendingUploads[newThreadID];
       const upload = uploads[localUploadID];
       if (!upload || !upload.abort || upload.serverID) {
         // The upload has been cancelled or completed before it failed
         return {};
       }
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [newThreadID]: {
             ...uploads,
             [localUploadID]: {
               ...upload,
               failed: true,
               progressPercent: 0,
               abort: null,
             },
           },
         },
       };
     });
   }
 
   queueMediaMissionReports(
     partials: $ReadOnlyArray<{
       mediaMission: MediaMission,
       uploadLocalID?: ?string,
       uploadServerID?: ?string,
       messageLocalID?: ?string,
     }>,
   ) {
     const reports = partials.map(
       ({ mediaMission, uploadLocalID, uploadServerID, messageLocalID }) => ({
         type: reportTypes.MEDIA_MISSION,
         time: Date.now(),
         platformDetails: getConfig().platformDetails,
         mediaMission,
         uploadServerID,
         uploadLocalID,
         messageLocalID,
         id: generateReportID(),
       }),
     );
     this.props.dispatch({ type: queueReportsActionType, payload: { reports } });
   }
 
   cancelPendingUpload = (threadInfo: ThreadInfo, localUploadID: string) => {
     let revokeURL: ?string, abortRequest: ?() => void;
     this.setState(
       prevState => {
         const newThreadID = this.getRealizedOrPendingThreadID(threadInfo.id);
         const currentPendingUploads = prevState.pendingUploads[newThreadID];
         if (!currentPendingUploads) {
           return {};
         }
         const pendingUpload = currentPendingUploads[localUploadID];
         if (!pendingUpload) {
           return {};
         }
         if (!pendingUpload.uriIsReal) {
           revokeURL = pendingUpload.uri;
         }
         if (pendingUpload.abort) {
           abortRequest = pendingUpload.abort;
         }
         if (pendingUpload.serverID) {
           const { serverID } = pendingUpload;
           if (!threadTypeIsThick(threadInfo.type)) {
             void this.props.deleteUpload({
               id: serverID,
               keyserverOrThreadID: threadInfo.id,
             });
           }
           if (isBlobServiceURI(pendingUpload.uri)) {
             const identityContext = this.props.identityContext;
             invariant(identityContext, 'Identity context should be set');
             invariant(
               pendingUpload.blobHolder,
               'blob service upload has no holder',
             );
             const endpoint = blobService.httpEndpoints.DELETE_BLOB;
             const holder = pendingUpload.blobHolder;
             const blobHash = blobHashFromBlobServiceURI(pendingUpload.uri);
             void (async () => {
               const authMetadata = await identityContext.getAuthMetadata();
               const defaultHeaders =
                 createDefaultHTTPRequestHeaders(authMetadata);
               await fetch(makeBlobServiceEndpointURL(endpoint), {
                 method: endpoint.method,
                 body: JSON.stringify({
                   holder,
                   blob_hash: blobHash,
                 }),
                 headers: {
                   ...defaultHeaders,
                   'content-type': 'application/json',
                 },
               });
             })();
           }
         }
         const newPendingUploads = _omit([localUploadID])(currentPendingUploads);
         return {
           pendingUploads: {
             ...prevState.pendingUploads,
             [newThreadID]: newPendingUploads,
           },
         };
       },
       () => {
         if (revokeURL) {
           URL.revokeObjectURL(revokeURL);
         }
         if (abortRequest) {
           abortRequest();
         }
       },
     );
   };
 
   async sendTextMessage(
     messageInfo: RawTextMessageInfo,
     inputThreadInfo: ThreadInfo,
     parentThreadInfo: ?ThreadInfo,
   ) {
     this.props.sendCallbacks.forEach(callback => callback());
 
     const { localID } = messageInfo;
     invariant(
       localID !== null && localID !== undefined,
       'localID should be set',
     );
     if (threadIsPendingSidebar(inputThreadInfo.id)) {
       this.pendingSidebarCreationMessageLocalIDs.add(localID);
     }
 
     if (!threadIsPending(inputThreadInfo.id)) {
       void this.props.dispatchActionPromise(
         sendTextMessageActionTypes,
         this.sendTextMessageAction(
           messageInfo,
           inputThreadInfo,
           parentThreadInfo,
         ),
         undefined,
         messageInfo,
       );
       return;
     }
 
     this.props.dispatch({
       type: sendTextMessageActionTypes.started,
       payload: messageInfo,
     });
 
     let threadInfo = inputThreadInfo;
     const { viewerID } = this.props;
     if (viewerID && threadTypeIsSidebar(inputThreadInfo.type)) {
       invariant(parentThreadInfo, 'sidebar should have parent');
       threadInfo = patchThreadInfoToIncludeMentionedMembersOfParent(
         inputThreadInfo,
         parentThreadInfo,
         messageInfo.text,
         viewerID,
       );
       if (threadInfo !== inputThreadInfo) {
         this.props.dispatch({
           type: updateNavInfoActionType,
           payload: { pendingThread: threadInfo },
         });
       }
     }
 
     let threadCreationResult = null;
     try {
       threadCreationResult = await this.startThreadCreation(threadInfo);
     } catch (e) {
-      const copy = cloneError(e);
-      copy.localID = messageInfo.localID;
-      copy.threadID = messageInfo.threadID;
+      const exceptionMessage = getMessageForException(e) ?? '';
+      const payload = new SendMessageError(
+        `Exception while creating thread: ${exceptionMessage}`,
+        messageInfo.localID ?? '',
+        messageInfo.threadID,
+      );
       this.props.dispatch({
         type: sendTextMessageActionTypes.failed,
-        payload: copy,
+        payload,
         error: true,
       });
       return;
     } finally {
       this.pendingThreadCreations.delete(threadInfo.id);
     }
 
     const newMessageInfo = {
       ...messageInfo,
       threadID: threadCreationResult?.threadID,
       time: Date.now(),
     };
 
     const newThreadInfo = {
       ...threadInfo,
       id: threadCreationResult?.threadID,
       type: threadCreationResult?.threadType ?? threadInfo.type,
     };
     void this.props.dispatchActionPromise(
       sendTextMessageActionTypes,
       this.sendTextMessageAction(
         newMessageInfo,
         newThreadInfo,
         parentThreadInfo,
       ),
       undefined,
       newMessageInfo,
     );
   }
 
   async sendTextMessageAction(
     messageInfo: RawTextMessageInfo,
     threadInfo: ThreadInfo,
     parentThreadInfo: ?ThreadInfo,
   ): Promise<SendMessagePayload> {
     try {
       if (!threadTypeIsThick(threadInfo.type)) {
         await this.props.textMessageCreationSideEffectsFunc(
           messageInfo,
           threadInfo,
           parentThreadInfo,
         );
       }
       const { localID } = messageInfo;
       invariant(
         localID !== null && localID !== undefined,
         'localID should be set',
       );
       const sidebarCreation =
         this.pendingSidebarCreationMessageLocalIDs.has(localID);
       const result = await this.props.sendTextMessage(
         messageInfo,
         threadInfo,
         parentThreadInfo,
         sidebarCreation,
       );
       if (threadTypeIsThick(threadInfo.type)) {
         await this.props.textMessageCreationSideEffectsFunc(
           messageInfo,
           threadInfo,
           parentThreadInfo,
         );
       }
       this.pendingSidebarCreationMessageLocalIDs.delete(localID);
       return result;
     } catch (e) {
-      const copy = cloneError(e);
-      copy.localID = messageInfo.localID;
-      copy.threadID = messageInfo.threadID;
-      throw copy;
+      const exceptionMessage = getMessageForException(e) ?? '';
+      throw new SendMessageError(
+        `Exception while sending text message: ${exceptionMessage}`,
+        messageInfo.localID ?? '',
+        messageInfo.threadID,
+      );
     }
   }
 
   // Creates a MultimediaMessage from the unassigned pending uploads,
   // if there are any
   createMultimediaMessage(threadInfo: ThreadInfo) {
     this.props.sendCallbacks.forEach(callback => callback());
 
     const localMessageID = getNextLocalID();
     void this.startThreadCreation(threadInfo);
 
     if (threadIsPendingSidebar(threadInfo.id)) {
       this.pendingSidebarCreationMessageLocalIDs.add(localMessageID);
     }
 
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadInfo.id);
       const currentPendingUploads = prevState.pendingUploads[newThreadID];
       if (!currentPendingUploads) {
         return {};
       }
       const newPendingUploads: { [string]: PendingMultimediaUpload } = {};
       let uploadAssigned = false;
       for (const localUploadID in currentPendingUploads) {
         const upload = currentPendingUploads[localUploadID];
         if (upload.messageID) {
           newPendingUploads[localUploadID] = upload;
         } else {
           const newUpload = {
             ...upload,
             messageID: localMessageID,
           };
           uploadAssigned = true;
           newPendingUploads[localUploadID] = newUpload;
         }
       }
       if (!uploadAssigned) {
         return {};
       }
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [newThreadID]: newPendingUploads,
         },
       };
     });
   }
 
   setDraft(threadID: ?string, draft: string) {
     invariant(threadID, 'threadID should be set in setDraft');
 
     const newThreadID = this.getRealizedOrPendingThreadID(threadID);
     this.props.dispatch({
       type: 'UPDATE_DRAFT',
       payload: {
         key: draftKeyFromThreadID(newThreadID),
         text: draft,
       },
     });
   }
 
   setTextCursorPosition(threadID: ?string, newPosition: number) {
     invariant(threadID, 'threadID should be set in setTextCursorPosition');
 
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadID);
       return {
         textCursorPositions: {
           ...prevState.textCursorPositions,
           [newThreadID]: newPosition,
         },
       };
     });
   }
 
   setTypeaheadState = (newState: Partial<TypeaheadState>) => {
     this.setState(prevState => ({
       typeaheadState: {
         ...prevState.typeaheadState,
         ...newState,
       },
     }));
   };
 
   setProgress(
     threadID: string,
     localUploadID: string,
     progressPercent: number,
   ) {
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadID);
       const pendingUploads = prevState.pendingUploads[newThreadID];
       if (!pendingUploads) {
         return {};
       }
       const pendingUpload = pendingUploads[localUploadID];
       if (!pendingUpload) {
         return {};
       }
       const newPendingUploads = {
         ...pendingUploads,
         [localUploadID]: {
           ...pendingUpload,
           progressPercent,
         },
       };
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [newThreadID]: newPendingUploads,
         },
       };
     });
   }
 
   messageHasUploadFailure(
     pendingUploads: ?$ReadOnlyArray<PendingMultimediaUpload>,
   ): boolean {
     if (!pendingUploads) {
       return false;
     }
     return pendingUploads.some(upload => upload.failed);
   }
 
   retryMultimediaMessage(
     localMessageID: string,
     threadInfo: ThreadInfo,
     pendingUploads: ?$ReadOnlyArray<PendingMultimediaUpload>,
   ) {
     this.props.sendCallbacks.forEach(callback => callback());
 
     const rawMessageInfo = this.getRawMultimediaMessageInfo(localMessageID);
     let newRawMessageInfo;
     // This conditional is for Flow
     if (rawMessageInfo.type === messageTypes.MULTIMEDIA) {
       newRawMessageInfo = ({
         ...rawMessageInfo,
         time: Date.now(),
       }: RawMediaMessageInfo);
     } else {
       newRawMessageInfo = ({
         ...rawMessageInfo,
         time: Date.now(),
       }: RawImagesMessageInfo);
     }
 
     void this.startThreadCreation(threadInfo);
 
     if (threadIsPendingSidebar(threadInfo.id)) {
       this.pendingSidebarCreationMessageLocalIDs.add(localMessageID);
     }
 
     const completed = InputStateContainer.completedMessageIDs(this.state);
     if (completed.has(localMessageID)) {
       void this.sendMultimediaMessage(newRawMessageInfo);
       return;
     }
 
     if (!pendingUploads) {
       return;
     }
 
     // We're not actually starting the send here,
     // we just use this action to update the message's timestamp in Redux
     this.props.dispatch({
       type: sendMultimediaMessageActionTypes.started,
       payload: newRawMessageInfo,
     });
 
     const uploadIDsToRetry = new Set<string>();
     const uploadsToRetry = [];
     for (const pendingUpload of pendingUploads) {
       const { serverID, messageID, localID, abort } = pendingUpload;
       if (serverID || messageID !== localMessageID) {
         continue;
       }
       if (abort) {
         abort();
       }
       uploadIDsToRetry.add(localID);
       uploadsToRetry.push(pendingUpload);
     }
 
     this.setState(prevState => {
       const newThreadID = this.getRealizedOrPendingThreadID(threadInfo.id);
       const prevPendingUploads = prevState.pendingUploads[newThreadID];
       if (!prevPendingUploads) {
         return {};
       }
       const newPendingUploads: { [string]: PendingMultimediaUpload } = {};
       let pendingUploadChanged = false;
       for (const localID in prevPendingUploads) {
         const pendingUpload = prevPendingUploads[localID];
         if (uploadIDsToRetry.has(localID) && !pendingUpload.serverID) {
           newPendingUploads[localID] = {
             ...pendingUpload,
             failed: false,
             progressPercent: 0,
             abort: null,
           };
           pendingUploadChanged = true;
         } else {
           newPendingUploads[localID] = pendingUpload;
         }
       }
       if (!pendingUploadChanged) {
         return {};
       }
       return {
         pendingUploads: {
           ...prevState.pendingUploads,
           [newThreadID]: newPendingUploads,
         },
       };
     });
 
     void this.uploadFiles(threadInfo, uploadsToRetry);
   }
 
   addReply = (message: string) => {
     this.replyCallbacks.forEach(addReplyCallback => addReplyCallback(message));
   };
 
   addReplyListener = (callbackReply: (message: string) => void) => {
     this.replyCallbacks.push(callbackReply);
   };
 
   removeReplyListener = (callbackReply: (message: string) => void) => {
     this.replyCallbacks = this.replyCallbacks.filter(
       candidate => candidate !== callbackReply,
     );
   };
 
   render(): React.Node {
     const { activeChatThreadID } = this.props;
 
     // we're going with two selectors as we want to avoid
     // recreation of chat state setter functions on typeahead state updates
     const inputBaseState = this.inputBaseStateSelector(activeChatThreadID)({
       ...this.state,
       ...this.props,
     });
 
     const typeaheadState = this.typeaheadStateSelector({
       ...this.state,
       ...this.props,
     });
 
     const inputState = this.inputStateSelector({
       inputBaseState,
       typeaheadState,
     });
 
     return (
       <InputStateContext.Provider value={inputState}>
         {this.props.children}
       </InputStateContext.Provider>
     );
   }
 }
 
 const ConnectedInputStateContainer: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedInputStateContainer(props) {
     const activeChatThreadID = useSelector(
       state => state.navInfo.activeChatThreadID,
     );
     const drafts = useSelector(state => state.draftStore.drafts);
     const viewerID = useSelector(
       state => state.currentUserInfo && state.currentUserInfo.id,
     );
     const messageStoreMessages = useSelector(
       state => state.messageStore.messages,
     );
     const pendingToRealizedThreadIDs = useSelector(state =>
       pendingToRealizedThreadIDsSelector(state.threadStore.threadInfos),
     );
     const calendarQuery = useSelector(nonThreadCalendarQuery);
     const callUploadMultimedia = useLegacyAshoatKeyserverCall(uploadMultimedia);
     const callBlobServiceUpload = useBlobServiceUpload();
     const callDeleteUpload = useDeleteUpload();
     const callSendMultimediaMessage =
       useInputStateContainerSendMultimediaMessage();
     const callSendTextMessage = useInputStateContainerSendTextMessage();
     const callNewThinThread = useNewThinThread();
     const callNewThickThread = useNewThickThread();
     const dispatch = useDispatch();
     const dispatchActionPromise = useDispatchActionPromise();
     const modalContext = useModalContext();
     const identityContext = React.useContext(IdentityClientContext);
 
     const [sendCallbacks, setSendCallbacks] = React.useState<
       $ReadOnlyArray<() => mixed>,
     >([]);
     const registerSendCallback = React.useCallback((callback: () => mixed) => {
       setSendCallbacks(prevCallbacks => [...prevCallbacks, callback]);
     }, []);
     const unregisterSendCallback = React.useCallback(
       (callback: () => mixed) => {
         setSendCallbacks(prevCallbacks =>
           prevCallbacks.filter(candidate => candidate !== callback),
         );
       },
       [],
     );
     const textMessageCreationSideEffectsFunc =
       useMessageCreationSideEffectsFunc<RawTextMessageInfo>(messageTypes.TEXT);
 
     return (
       <InputStateContainer
         {...props}
         activeChatThreadID={activeChatThreadID}
         drafts={drafts}
         viewerID={viewerID}
         messageStoreMessages={messageStoreMessages}
         pendingRealizedThreadIDs={pendingToRealizedThreadIDs}
         calendarQuery={calendarQuery}
         uploadMultimedia={callUploadMultimedia}
         blobServiceUpload={callBlobServiceUpload}
         deleteUpload={callDeleteUpload}
         sendMultimediaMessage={callSendMultimediaMessage}
         sendTextMessage={callSendTextMessage}
         newThinThread={callNewThinThread}
         newThickThread={callNewThickThread}
         dispatch={dispatch}
         dispatchActionPromise={dispatchActionPromise}
         pushModal={modalContext.pushModal}
         sendCallbacks={sendCallbacks}
         registerSendCallback={registerSendCallback}
         unregisterSendCallback={unregisterSendCallback}
         textMessageCreationSideEffectsFunc={textMessageCreationSideEffectsFunc}
         identityContext={identityContext}
       />
     );
   });
 
 export default ConnectedInputStateContainer;