diff --git a/lib/actions/thread-actions.js b/lib/actions/thread-actions.js
index 03662c0c7..de6f021bd 100644
--- a/lib/actions/thread-actions.js
+++ b/lib/actions/thread-actions.js
@@ -1,559 +1,570 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import uuid from 'uuid';
 
 import genesis from '../facts/genesis.js';
 import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
 import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
 import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
 import {
   type OutboundDMOperationSpecification,
   dmOperationSpecificationTypes,
   getCreateThickRawThreadInfoInputFromThreadInfo,
 } from '../shared/dm-ops/dm-op-utils.js';
 import { useProcessAndSendDMOperation } from '../shared/dm-ops/process-dm-ops.js';
 import { permissionsAndAuthRelatedRequestTimeout } from '../shared/timeouts.js';
 import type {
   DMChangeThreadSettingsOperation,
   DMThreadSettingsChanges,
   DMJoinThreadOperation,
 } from '../types/dm-ops.js';
 import type {
   ThreadInfo,
   RawThreadInfo,
 } from '../types/minimally-encoded-thread-permissions-types.js';
-import {
-  thickThreadTypes,
-  threadTypeIsThick,
-} from '../types/thread-types-enum.js';
+import { thickThreadTypes } from '../types/thread-types-enum.js';
 import type {
   ChangeThreadSettingsPayload,
   LeaveThreadPayload,
   UpdateThreadRequest,
   ClientNewThinThreadRequest,
   NewThreadResult,
   ClientThreadJoinRequest,
   ThreadJoinPayload,
   ThreadFetchMediaRequest,
   ThreadFetchMediaResult,
   RoleModificationRequest,
   RoleModificationPayload,
   RoleDeletionRequest,
   RoleDeletionPayload,
+  UpdateThickThreadRequest,
 } from '../types/thread-types.js';
 import { values } from '../utils/objects.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 export type DeleteThreadInput = {
   +threadID: string,
 };
 
 const deleteThreadActionTypes = Object.freeze({
   started: 'DELETE_THREAD_STARTED',
   success: 'DELETE_THREAD_SUCCESS',
   failed: 'DELETE_THREAD_FAILED',
 });
 
 const deleteThreadEndpointOptions = {
   timeout: permissionsAndAuthRelatedRequestTimeout,
 };
 
 const deleteThread =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: DeleteThreadInput) => Promise<LeaveThreadPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'delete_thread',
       requests,
       deleteThreadEndpointOptions,
     );
     const response = responses[keyserverID];
     return {
       updatesResult: response.updatesResult,
     };
   };
 
 function useDeleteThread(): (
   input: DeleteThreadInput,
 ) => Promise<LeaveThreadPayload> {
   return useKeyserverCall(deleteThread);
 }
 const changeThreadSettingsActionTypes = Object.freeze({
   started: 'CHANGE_THREAD_SETTINGS_STARTED',
   success: 'CHANGE_THREAD_SETTINGS_SUCCESS',
   failed: 'CHANGE_THREAD_SETTINGS_FAILED',
 });
 
 const changeThreadSettingsEndpointOptions = {
   timeout: permissionsAndAuthRelatedRequestTimeout,
 };
 
 const changeThreadSettings =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: UpdateThreadRequest) => Promise<ChangeThreadSettingsPayload>) =>
   async input => {
     invariant(
       Object.keys(input.changes).length > 0,
       'No changes provided to changeThreadSettings!',
     );
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'update_thread',
       requests,
       changeThreadSettingsEndpointOptions,
     );
     const response = responses[keyserverID];
     return {
       threadID: input.threadID,
       updatesResult: response.updatesResult,
       newMessageInfos: response.newMessageInfos,
     };
   };
 
-function useChangeThreadSettings(
-  threadInfo: ?ThreadInfo,
-): (input: UpdateThreadRequest) => Promise<ChangeThreadSettingsPayload> {
+export type UseChangeThreadSettingsInput = $ReadOnly<
+  | {
+      ...UpdateThreadRequest,
+      +thick: false,
+    }
+  | {
+      ...UpdateThickThreadRequest,
+      +thick: true,
+      +threadInfo: ThreadInfo,
+    },
+>;
+
+function useChangeThreadSettings(): (
+  input: UseChangeThreadSettingsInput,
+) => Promise<ChangeThreadSettingsPayload> {
   const processAndSendDMOperation = useProcessAndSendDMOperation();
   const viewerID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
 
   const keyserverCall = useKeyserverCall(changeThreadSettings);
 
   return React.useCallback(
-    async (input: UpdateThreadRequest) => {
-      if (!threadInfo || !threadTypeIsThick(threadInfo.type)) {
-        return await keyserverCall(input);
+    async (input: UseChangeThreadSettingsInput) => {
+      if (!input.thick) {
+        const { thick, ...rest } = input;
+        return await keyserverCall({ ...rest });
       }
 
       invariant(viewerID, 'viewerID should be set');
 
       const changes: { ...DMThreadSettingsChanges } = {};
       if (input.changes.name) {
         changes.name = input.changes.name;
       }
       if (input.changes.description) {
         changes.description = input.changes.description;
       }
       if (input.changes.color) {
         changes.color = input.changes.color;
       }
       if (input.changes.avatar && input.changes.avatar.type === 'emoji') {
         changes.avatar = {
           type: 'emoji',
           emoji: input.changes.avatar.emoji,
           color: input.changes.avatar.color,
         };
       } else if (input.changes.avatar && input.changes.avatar.type === 'ens') {
         changes.avatar = { type: 'ens' };
       }
       // To support `image` and `encrypted_image` avatars we first, need stop
       // sending multimedia metadata to keyserver.
       // ENG-8708
-
+      const { threadInfo } = input;
       const op: DMChangeThreadSettingsOperation = {
         type: 'change_thread_settings',
         threadID: threadInfo.id,
         editorID: viewerID,
         time: Date.now(),
         changes,
         messageIDsPrefix: uuid.v4(),
       };
       const opSpecification: OutboundDMOperationSpecification = {
         type: dmOperationSpecificationTypes.OUTBOUND,
         op,
         recipients: {
           type: 'all_thread_members',
           threadID:
             threadInfo.type === thickThreadTypes.THICK_SIDEBAR &&
             threadInfo.parentThreadID
               ? threadInfo.parentThreadID
               : threadInfo.id,
         },
       };
 
       await processAndSendDMOperation(opSpecification);
       return ({
         threadID: threadInfo.id,
         updatesResult: { newUpdates: [] },
         newMessageInfos: [],
       }: ChangeThreadSettingsPayload);
     },
-    [keyserverCall, processAndSendDMOperation, threadInfo, viewerID],
+    [keyserverCall, processAndSendDMOperation, viewerID],
   );
 }
 
 export type RemoveUsersFromThreadInput = {
   +threadID: string,
   +memberIDs: $ReadOnlyArray<string>,
 };
 
 const removeUsersFromThreadActionTypes = Object.freeze({
   started: 'REMOVE_USERS_FROM_THREAD_STARTED',
   success: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
   failed: 'REMOVE_USERS_FROM_THREAD_FAILED',
 });
 
 const removeMembersFromThreadEndpointOptions = {
   timeout: permissionsAndAuthRelatedRequestTimeout,
 };
 
 const removeUsersFromThread =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: RemoveUsersFromThreadInput,
   ) => Promise<ChangeThreadSettingsPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'remove_members',
       requests,
       removeMembersFromThreadEndpointOptions,
     );
     const response = responses[keyserverID];
     return {
       threadID: input.threadID,
       updatesResult: response.updatesResult,
       newMessageInfos: response.newMessageInfos,
     };
   };
 
 function useRemoveUsersFromThread(): (
   input: RemoveUsersFromThreadInput,
 ) => Promise<ChangeThreadSettingsPayload> {
   return useKeyserverCall(removeUsersFromThread);
 }
 
 export type ChangeThreadMemberRolesInput = {
   +threadID: string,
   +memberIDs: $ReadOnlyArray<string>,
   +newRole: string,
 };
 
 const changeThreadMemberRolesActionTypes = Object.freeze({
   started: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
   success: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
   failed: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
 });
 
 const changeThreadMemberRoleEndpointOptions = {
   timeout: permissionsAndAuthRelatedRequestTimeout,
 };
 
 const changeThreadMemberRoles =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((
     input: ChangeThreadMemberRolesInput,
   ) => Promise<ChangeThreadSettingsPayload>) =>
   async input => {
     const { threadID, memberIDs, newRole } = input;
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = {
       [keyserverID]: {
         threadID,
         memberIDs,
         role: newRole,
       },
     };
 
     const responses = await callKeyserverEndpoint(
       'update_role',
       requests,
       changeThreadMemberRoleEndpointOptions,
     );
     const response = responses[keyserverID];
     return {
       threadID,
       updatesResult: response.updatesResult,
       newMessageInfos: response.newMessageInfos,
     };
   };
 
 function useChangeThreadMemberRoles(): (
   input: ChangeThreadMemberRolesInput,
 ) => Promise<ChangeThreadSettingsPayload> {
   return useKeyserverCall(changeThreadMemberRoles);
 }
 
 const newThreadActionTypes = Object.freeze({
   started: 'NEW_THREAD_STARTED',
   success: 'NEW_THREAD_SUCCESS',
   failed: 'NEW_THREAD_FAILED',
 });
 const newThinThread =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: ClientNewThinThreadRequest) => Promise<NewThreadResult>) =>
   async input => {
     const parentThreadID = input.parentThreadID ?? genesis().id;
     const keyserverID = extractKeyserverIDFromID(parentThreadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint('create_thread', requests);
     const response = responses[keyserverID];
 
     return {
       newThreadID: response.newThreadID,
       updatesResult: response.updatesResult,
       newMessageInfos: response.newMessageInfos,
       userInfos: response.userInfos,
     };
   };
 
 function useNewThinThread(): (
   input: ClientNewThinThreadRequest,
 ) => Promise<NewThreadResult> {
   return useKeyserverCall(newThinThread);
 }
 
 const joinThreadActionTypes = Object.freeze({
   started: 'JOIN_THREAD_STARTED',
   success: 'JOIN_THREAD_SUCCESS',
   failed: 'JOIN_THREAD_FAILED',
 });
 const joinThreadOptions = {
   timeout: permissionsAndAuthRelatedRequestTimeout,
 };
 const joinThread =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: ClientThreadJoinRequest) => Promise<ThreadJoinPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'join_thread',
       requests,
       joinThreadOptions,
     );
     const response = responses[keyserverID];
     const userInfos = values(response.userInfos);
     return {
       updatesResult: response.updatesResult,
       rawMessageInfos: response.rawMessageInfos,
       truncationStatuses: response.truncationStatuses,
       userInfos,
       keyserverID,
     };
   };
 
 export type UseJoinThreadInput = $ReadOnly<
   | {
       +thick: false,
       ...ClientThreadJoinRequest,
     }
   | {
       +thick: true,
       +rawThreadInfo: RawThreadInfo,
     },
 >;
 
 function useJoinThread(): (
   input: UseJoinThreadInput,
 ) => Promise<ThreadJoinPayload> {
   const processAndSendDMOperation = useProcessAndSendDMOperation();
   const viewerID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
   const keyserverCall = useKeyserverCall(joinThread);
   return React.useCallback(
     async (input: UseJoinThreadInput) => {
       if (!input.thick) {
         const { thick, ...rest } = input;
         return await keyserverCall({ ...rest });
       }
 
       const { rawThreadInfo } = input;
 
       invariant(viewerID, 'viewerID should be set');
       invariant(rawThreadInfo.thick, 'thread must be thick');
 
       const existingThreadDetails =
         getCreateThickRawThreadInfoInputFromThreadInfo(rawThreadInfo);
 
       const op: DMJoinThreadOperation = {
         type: 'join_thread',
         joinerID: viewerID,
         time: Date.now(),
         messageID: uuid.v4(),
         existingThreadDetails,
       };
 
       const opSpecification: OutboundDMOperationSpecification = {
         type: dmOperationSpecificationTypes.OUTBOUND,
         op,
         recipients: {
           type: 'all_thread_members',
           threadID:
             rawThreadInfo.type === thickThreadTypes.THICK_SIDEBAR &&
             rawThreadInfo.parentThreadID
               ? rawThreadInfo.parentThreadID
               : rawThreadInfo.id,
         },
       };
 
       await processAndSendDMOperation(opSpecification);
       return ({
         updatesResult: { newUpdates: [] },
         rawMessageInfos: [],
         truncationStatuses: {},
         userInfos: [],
       }: ThreadJoinPayload);
     },
     [keyserverCall, processAndSendDMOperation, viewerID],
   );
 }
 
 export type LeaveThreadInput = {
   +threadID: string,
 };
 const leaveThreadActionTypes = Object.freeze({
   started: 'LEAVE_THREAD_STARTED',
   success: 'LEAVE_THREAD_SUCCESS',
   failed: 'LEAVE_THREAD_FAILED',
 });
 const leaveThreadEndpointOptions = {
   timeout: permissionsAndAuthRelatedRequestTimeout,
 };
 const leaveThread =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: LeaveThreadInput) => Promise<LeaveThreadPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'leave_thread',
       requests,
       leaveThreadEndpointOptions,
     );
     const response = responses[keyserverID];
     return {
       updatesResult: response.updatesResult,
     };
   };
 
 function useLeaveThread(): (
   input: LeaveThreadInput,
 ) => Promise<LeaveThreadPayload> {
   return useKeyserverCall(leaveThread);
 }
 
 const fetchThreadMedia =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: ThreadFetchMediaRequest) => Promise<ThreadFetchMediaResult>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.threadID);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'fetch_thread_media',
       requests,
     );
     const response = responses[keyserverID];
     return { media: response.media };
   };
 
 function useFetchThreadMedia(): (
   input: ThreadFetchMediaRequest,
 ) => Promise<ThreadFetchMediaResult> {
   return useKeyserverCall(fetchThreadMedia);
 }
 
 const modifyCommunityRoleActionTypes = Object.freeze({
   started: 'MODIFY_COMMUNITY_ROLE_STARTED',
   success: 'MODIFY_COMMUNITY_ROLE_SUCCESS',
   failed: 'MODIFY_COMMUNITY_ROLE_FAILED',
 });
 const modifyCommunityRole =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: RoleModificationRequest) => Promise<RoleModificationPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.community);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'modify_community_role',
       requests,
     );
     const response = responses[keyserverID];
     return {
       threadInfo: response.threadInfo,
       updatesResult: response.updatesResult,
     };
   };
 
 function useModifyCommunityRole(): (
   input: RoleModificationRequest,
 ) => Promise<RoleModificationPayload> {
   return useKeyserverCall(modifyCommunityRole);
 }
 
 const deleteCommunityRoleActionTypes = Object.freeze({
   started: 'DELETE_COMMUNITY_ROLE_STARTED',
   success: 'DELETE_COMMUNITY_ROLE_SUCCESS',
   failed: 'DELETE_COMMUNITY_ROLE_FAILED',
 });
 const deleteCommunityRole =
   (
     callKeyserverEndpoint: CallKeyserverEndpoint,
   ): ((input: RoleDeletionRequest) => Promise<RoleDeletionPayload>) =>
   async input => {
     const keyserverID = extractKeyserverIDFromID(input.community);
     const requests = { [keyserverID]: input };
 
     const responses = await callKeyserverEndpoint(
       'delete_community_role',
       requests,
     );
     const response = responses[keyserverID];
     return {
       threadInfo: response.threadInfo,
       updatesResult: response.updatesResult,
     };
   };
 
 function useDeleteCommunityRole(): (
   input: RoleDeletionRequest,
 ) => Promise<RoleDeletionPayload> {
   return useKeyserverCall(deleteCommunityRole);
 }
 
 export {
   deleteThreadActionTypes,
   useDeleteThread,
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
   removeUsersFromThreadActionTypes,
   useRemoveUsersFromThread,
   changeThreadMemberRolesActionTypes,
   useChangeThreadMemberRoles,
   newThreadActionTypes,
   useNewThinThread,
   joinThreadActionTypes,
   useJoinThread,
   leaveThreadActionTypes,
   useLeaveThread,
   useFetchThreadMedia,
   modifyCommunityRoleActionTypes,
   useModifyCommunityRole,
   deleteCommunityRoleActionTypes,
   useDeleteCommunityRole,
 };
diff --git a/lib/components/base-edit-thread-avatar-provider.react.js b/lib/components/base-edit-thread-avatar-provider.react.js
index 93483944f..ff39df673 100644
--- a/lib/components/base-edit-thread-avatar-provider.react.js
+++ b/lib/components/base-edit-thread-avatar-provider.react.js
@@ -1,122 +1,127 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   useChangeThreadSettings,
   changeThreadSettingsActionTypes,
 } from '../actions/thread-actions.js';
 import { createLoadingStatusSelector } from '../selectors/loading-selectors.js';
 import { threadInfoSelector } from '../selectors/thread-selectors.js';
 import type { UpdateUserAvatarRequest } from '../types/avatar-types.js';
 import type { LoadingStatus } from '../types/loading-types.js';
-import type { UpdateThreadRequest } from '../types/thread-types.js';
+import { threadTypeIsThick } from '../types/thread-types-enum.js';
 import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 export type EditThreadAvatarContextType = {
   +updateThreadAvatarMediaUploadInProgress: (inProgress: boolean) => void,
   +threadAvatarSaveInProgress: boolean,
   +baseSetThreadAvatar: (
     threadID: string,
     avatarRequest: UpdateUserAvatarRequest,
   ) => Promise<void>,
 };
 
 const EditThreadAvatarContext: React.Context<?EditThreadAvatarContextType> =
   React.createContext<?EditThreadAvatarContextType>();
 
 type Props = {
   +activeThreadID: string,
   +children: React.Node,
 };
 function BaseEditThreadAvatarProvider(props: Props): React.Node {
   const { activeThreadID, children } = props;
 
   const updateThreadAvatarLoadingStatus: LoadingStatus = useSelector(
     createLoadingStatusSelector(
       changeThreadSettingsActionTypes,
       `${changeThreadSettingsActionTypes.started}:${activeThreadID}:avatar`,
     ),
   );
 
   const threadInfo = useSelector(
     state => threadInfoSelector(state)[activeThreadID],
   );
   const dispatchActionPromise = useDispatchActionPromise();
-  const changeThreadSettingsCall = useChangeThreadSettings(threadInfo);
+  const changeThreadSettingsCall = useChangeThreadSettings();
 
   const [
     threadAvatarMediaUploadInProgress,
     setThreadAvatarMediaUploadInProgress,
   ] = React.useState<$ReadOnlySet<string>>(new Set<string>());
 
   const updateThreadAvatarMediaUploadInProgress = React.useCallback(
     (inProgress: boolean) =>
       setThreadAvatarMediaUploadInProgress(prevState => {
         const updatedSet = new Set(prevState);
         if (inProgress) {
           updatedSet.add(activeThreadID);
         } else {
           updatedSet.delete(activeThreadID);
         }
         return updatedSet;
       }),
     [activeThreadID],
   );
 
   const threadAvatarSaveInProgress =
     threadAvatarMediaUploadInProgress.has(activeThreadID) ||
     updateThreadAvatarLoadingStatus === 'loading';
 
   // NOTE: Do NOT consume `baseSetThreadAvatar` directly.
   //       Use platform-specific `[web/native]SetThreadAvatar` instead.
   const baseSetThreadAvatar = React.useCallback(
     async (threadID: string, avatarRequest: UpdateUserAvatarRequest) => {
-      const updateThreadRequest: UpdateThreadRequest = {
+      const updateThreadRequest = {
         threadID,
         changes: {
           avatar: avatarRequest,
         },
       };
       const action = changeThreadSettingsActionTypes.started;
       if (
         avatarRequest.type === 'image' ||
         avatarRequest.type === 'encrypted_image'
       ) {
         updateThreadAvatarMediaUploadInProgress(false);
       }
-      const promise = changeThreadSettingsCall(updateThreadRequest);
+      const updateThreadInput = threadTypeIsThick(threadInfo.type)
+        ? { thick: true, threadInfo, ...updateThreadRequest }
+        : { thick: false, ...updateThreadRequest };
+
+      const promise = changeThreadSettingsCall(updateThreadInput);
       void dispatchActionPromise(changeThreadSettingsActionTypes, promise, {
         customKeyName: `${action}:${threadID}:avatar`,
       });
       await promise;
     },
     [
+      threadInfo,
       changeThreadSettingsCall,
       dispatchActionPromise,
       updateThreadAvatarMediaUploadInProgress,
     ],
   );
 
   const context = React.useMemo(
     () => ({
       updateThreadAvatarMediaUploadInProgress,
       threadAvatarSaveInProgress,
       baseSetThreadAvatar,
     }),
     [
       updateThreadAvatarMediaUploadInProgress,
       threadAvatarSaveInProgress,
       baseSetThreadAvatar,
     ],
   );
 
   return (
     <EditThreadAvatarContext.Provider value={context}>
       {children}
     </EditThreadAvatarContext.Provider>
   );
 }
 
 export { EditThreadAvatarContext, BaseEditThreadAvatarProvider };
diff --git a/lib/hooks/promote-sidebar.react.js b/lib/hooks/promote-sidebar.react.js
index 6a1c6c32a..5d82f0dc3 100644
--- a/lib/hooks/promote-sidebar.react.js
+++ b/lib/hooks/promote-sidebar.react.js
@@ -1,95 +1,96 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
 } from '../actions/thread-actions.js';
 import { createLoadingStatusSelector } from '../selectors/loading-selectors.js';
 import { threadInfoSelector } from '../selectors/thread-selectors.js';
 import {
   threadIsSidebar,
   useThreadHasPermission,
 } from '../shared/thread-utils.js';
 import type { LoadingStatus } from '../types/loading-types.js';
 import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types.js';
 import { threadPermissions } from '../types/thread-permission-types.js';
 import { threadTypes } from '../types/thread-types-enum.js';
 import { useDispatchActionPromise } from '../utils/redux-promise-utils.js';
 import { useSelector } from '../utils/redux-utils.js';
 
 function useCanPromoteSidebar(
   sidebarThreadInfo: ThreadInfo,
   parentThreadInfo: ?ThreadInfo,
 ): boolean {
   const canChangeThreadType = useThreadHasPermission(
     sidebarThreadInfo,
     threadPermissions.EDIT_PERMISSIONS,
   );
   const canCreateSubchannelsInParent = useThreadHasPermission(
     parentThreadInfo,
     threadPermissions.CREATE_SUBCHANNELS,
   );
 
   return (
     threadIsSidebar(sidebarThreadInfo) &&
     canChangeThreadType &&
     canCreateSubchannelsInParent
   );
 }
 
 type PromoteSidebarType = {
   +onPromoteSidebar: () => void,
   +loading: LoadingStatus,
   +canPromoteSidebar: boolean,
 };
 
 function usePromoteSidebar(
   threadInfo: ThreadInfo,
   onError?: () => mixed,
 ): PromoteSidebarType {
   const dispatchActionPromise = useDispatchActionPromise();
   const callChangeThreadSettings = useChangeThreadSettings();
   const loadingStatusSelector = createLoadingStatusSelector(
     changeThreadSettingsActionTypes,
   );
   const loadingStatus = useSelector(loadingStatusSelector);
 
   const { parentThreadID } = threadInfo;
   const parentThreadInfo: ?ThreadInfo = useSelector(state =>
     parentThreadID ? threadInfoSelector(state)[parentThreadID] : null,
   );
 
   const canPromote = useCanPromoteSidebar(threadInfo, parentThreadInfo);
 
   const onClick = React.useCallback(() => {
     try {
       void dispatchActionPromise(
         changeThreadSettingsActionTypes,
         (async () => {
           return await callChangeThreadSettings({
+            thick: false,
             threadID: threadInfo.id,
             changes: { type: threadTypes.COMMUNITY_OPEN_SUBTHREAD },
           });
         })(),
       );
     } catch (e) {
       onError?.();
       throw e;
     }
   }, [threadInfo.id, callChangeThreadSettings, dispatchActionPromise, onError]);
 
   const returnValues = React.useMemo(
     () => ({
       onPromoteSidebar: onClick,
       loading: loadingStatus,
       canPromoteSidebar: canPromote,
     }),
     [onClick, loadingStatus, canPromote],
   );
 
   return returnValues;
 }
 
 export { usePromoteSidebar, useCanPromoteSidebar };
diff --git a/lib/shared/messages/text-message-spec.js b/lib/shared/messages/text-message-spec.js
index e54939dd9..ecc520015 100644
--- a/lib/shared/messages/text-message-spec.js
+++ b/lib/shared/messages/text-message-spec.js
@@ -1,334 +1,353 @@
 // @flow
 
 import invariant from 'invariant';
 import * as SimpleMarkdown from 'simple-markdown';
 
 import {
   type MessageSpec,
   type NotificationTextsParams,
   pushTypes,
   type RawMessageInfoFromServerDBRowParams,
 } from './message-spec.js';
 import { assertSingleMessageInfo, joinResult } from './utils.js';
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
 } from '../../actions/thread-actions.js';
 import { messageTypes } from '../../types/message-types-enum.js';
 import type {
   ClientDBMessageInfo,
   MessageInfo,
 } from '../../types/message-types.js';
 import {
   type RawTextMessageInfo,
   rawTextMessageInfoValidator,
   type TextMessageData,
   type TextMessageInfo,
 } from '../../types/messages/text.js';
 import type { ThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
 import type { NotifTexts } from '../../types/notif-types.js';
-import { threadTypeIsSidebar } from '../../types/thread-types-enum.js';
+import {
+  threadTypeIsSidebar,
+  threadTypeIsThick,
+} from '../../types/thread-types-enum.js';
 import type { RelativeUserInfo } from '../../types/user-types.js';
 import { ET } from '../../utils/entity-text.js';
 import { useDispatchActionPromise } from '../../utils/redux-promise-utils.js';
+import { useAddDMThreadMembers } from '../dm-ops/dm-op-utils.js';
 import {
   type ASTNode,
   type SingleASTNode,
   stripSpoilersFromMarkdownAST,
   stripSpoilersFromNotifications,
 } from '../markdown.js';
 import {
   isUserMentioned,
   renderChatMentionsWithAltText,
 } from '../mention-utils.js';
 import { notifTextsForSidebarCreation } from '../notif-utils.js';
 import {
   extractNewMentionedParentMembers,
   threadIsGroupChat,
 } from '../thread-utils.js';
 
 /**
  * most of the markdown leaves contain `content` field
  * (it is an array or a string) apart from lists,
  * which have `items` field (that holds an array)
  */
 const rawTextFromMarkdownAST = (node: ASTNode): string => {
   if (Array.isArray(node)) {
     return node.map(rawTextFromMarkdownAST).join('');
   }
   const { content, items } = node;
   if (content && typeof content === 'string') {
     return content;
   } else if (items) {
     return rawTextFromMarkdownAST(items);
   } else if (content) {
     return rawTextFromMarkdownAST(content);
   }
   return '';
 };
 
 const getFirstNonQuotedRawLine = (
   nodes: $ReadOnlyArray<SingleASTNode>,
 ): string => {
   let result = 'message';
   for (const node of nodes) {
     if (node.type === 'blockQuote') {
       result = 'quoted message';
     } else {
       const rawText = rawTextFromMarkdownAST(node);
       if (!rawText || !rawText.replace(/\s/g, '')) {
         // handles the case of an empty(or containing only white spaces)
         // new line that usually occurs between a quote and the rest
         // of the message(we don't want it as a title, thus continue)
         continue;
       }
       return rawText;
     }
   }
   return result;
 };
 
 type TextMessageSpec = MessageSpec<
   TextMessageData,
   RawTextMessageInfo,
   TextMessageInfo,
 > & {
   // We need to explicitly type this as non-optional so that
   // it can be referenced from messageContentForClientDB below
   +messageContentForServerDB: (
     data: TextMessageData | RawTextMessageInfo,
   ) => string,
   ...
 };
 
 export const textMessageSpec: TextMessageSpec = Object.freeze({
   messageContentForServerDB(
     data: TextMessageData | RawTextMessageInfo,
   ): string {
     return data.text;
   },
 
   messageContentForClientDB(data: RawTextMessageInfo): string {
     return textMessageSpec.messageContentForServerDB(data);
   },
 
   messageTitle({ messageInfo, markdownRules }) {
     const { text } = messageInfo;
     const parser = SimpleMarkdown.parserFor(markdownRules);
     const ast = stripSpoilersFromMarkdownAST(
       parser(text, { disableAutoBlockNewlines: true }),
     );
     return ET`${getFirstNonQuotedRawLine(ast).trim()}`;
   },
 
   rawMessageInfoFromServerDBRow(
     row: Object,
     params: RawMessageInfoFromServerDBRowParams,
   ): RawTextMessageInfo {
     let rawTextMessageInfo: RawTextMessageInfo = {
       type: messageTypes.TEXT,
       id: row.id.toString(),
       threadID: row.threadID.toString(),
       time: row.time,
       creatorID: row.creatorID.toString(),
       text: row.content,
     };
     if (params.localID) {
       rawTextMessageInfo = { ...rawTextMessageInfo, localID: params.localID };
     }
     return rawTextMessageInfo;
   },
 
   rawMessageInfoFromClientDB(
     clientDBMessageInfo: ClientDBMessageInfo,
   ): RawTextMessageInfo {
     let rawTextMessageInfo: RawTextMessageInfo = {
       type: messageTypes.TEXT,
       threadID: clientDBMessageInfo.thread,
       time: parseInt(clientDBMessageInfo.time),
       creatorID: clientDBMessageInfo.user,
       text: clientDBMessageInfo.content ?? '',
     };
     if (clientDBMessageInfo.local_id) {
       rawTextMessageInfo = {
         ...rawTextMessageInfo,
         localID: clientDBMessageInfo.local_id,
       };
     }
     if (clientDBMessageInfo.id !== clientDBMessageInfo.local_id) {
       rawTextMessageInfo = {
         ...rawTextMessageInfo,
         id: clientDBMessageInfo.id,
       };
     }
     return rawTextMessageInfo;
   },
 
   createMessageInfo(
     rawMessageInfo: RawTextMessageInfo,
     creator: RelativeUserInfo,
   ): TextMessageInfo {
     let messageInfo: TextMessageInfo = {
       type: messageTypes.TEXT,
       threadID: rawMessageInfo.threadID,
       creator,
       time: rawMessageInfo.time,
       text: rawMessageInfo.text,
     };
     if (rawMessageInfo.id) {
       messageInfo = { ...messageInfo, id: rawMessageInfo.id };
     }
     if (rawMessageInfo.localID) {
       messageInfo = { ...messageInfo, localID: rawMessageInfo.localID };
     }
     return messageInfo;
   },
 
   rawMessageInfoFromMessageData(
     messageData: TextMessageData,
     id: ?string,
   ): RawTextMessageInfo {
     const { sidebarCreation, ...rest } = messageData;
     if (id) {
       return { ...rest, id };
     } else {
       return { ...rest };
     }
   },
 
   async notificationTexts(
     messageInfos: $ReadOnlyArray<MessageInfo>,
     threadInfo: ThreadInfo,
     params: NotificationTextsParams,
   ): Promise<?NotifTexts> {
     // We special-case sidebarCreations. Usually we don't send any notifs in
     // that case to avoid a double-notif, but we need to update the original
     // notif if somebody was @-tagged in this message
     if (
       messageInfos.length === 3 &&
       messageInfos[2].type === messageTypes.SIDEBAR_SOURCE &&
       messageInfos[1].type === messageTypes.CREATE_SIDEBAR
     ) {
       const sidebarSourceMessageInfo = messageInfos[2];
       const createSidebarMessageInfo = messageInfos[1];
 
       const sourceMessage = messageInfos[2].sourceMessage;
       const { username } = params.notifTargetUserInfo;
       if (!username) {
         // If we couldn't fetch the username for some reason, we won't be able
         // to extract @-mentions anyways, so we'll give up on updating the notif
         return null;
       }
 
       if (
         sourceMessage.type === messageTypes.TEXT &&
         isUserMentioned(username, sourceMessage.text)
       ) {
         // If the notif target was already mentioned in the source message,
         // there's no need to update the notif
         return null;
       }
 
       const messageInfo = messageInfos[0];
       invariant(
         messageInfo.type === messageTypes.TEXT,
         'messageInfo should be messageTypes.TEXT!',
       );
       if (!isUserMentioned(username, messageInfo.text)) {
         // We only need to update the notif if the notif target is mentioned
         return null;
       }
 
       return notifTextsForSidebarCreation({
         createSidebarMessageInfo,
         sidebarSourceMessageInfo,
         firstSidebarMessageInfo: messageInfo,
         threadInfo,
         params,
       });
     }
 
     const messageInfo = assertSingleMessageInfo(messageInfos);
     invariant(
       messageInfo.type === messageTypes.TEXT,
       'messageInfo should be messageTypes.TEXT!',
     );
     const transformedNotificationText = stripSpoilersFromNotifications(
       renderChatMentionsWithAltText(messageInfo.text),
     );
     if (!threadInfo.name && !threadIsGroupChat(threadInfo)) {
       const thread = ET.thread({ display: 'uiName', threadInfo });
       return {
         merged: ET`${thread}: ${transformedNotificationText}`,
         body: transformedNotificationText,
         title: threadInfo.uiName,
       };
     } else {
       const creator = ET.user({ userInfo: messageInfo.creator });
       const thread = ET.thread({ display: 'shortName', threadInfo });
       return {
         merged: ET`${creator} to ${thread}: ${transformedNotificationText}`,
         body: transformedNotificationText,
         title: threadInfo.uiName,
         prefix: ET`${creator}:`,
       };
     }
   },
 
   notificationCollapseKey(
     rawMessageInfo: RawTextMessageInfo,
     messageData: TextMessageData,
   ): ?string {
     if (!messageData.sidebarCreation) {
       return null;
     }
     return joinResult(messageTypes.CREATE_SIDEBAR, rawMessageInfo.threadID);
   },
 
   generatesNotifs: async () => pushTypes.NOTIF,
 
   includedInRepliesCount: true,
 
   useCreationSideEffectsFunc: () => {
     const dispatchActionPromise = useDispatchActionPromise();
     const callChangeThreadSettings = useChangeThreadSettings();
+    const callAddDMThreadMembers = useAddDMThreadMembers();
     return async (
       messageInfo: RawTextMessageInfo,
       threadInfo: ThreadInfo,
       parentThreadInfo: ?ThreadInfo,
     ) => {
       if (!threadTypeIsSidebar(threadInfo.type)) {
         return;
       }
       invariant(parentThreadInfo, 'all sidebars should have a parent thread');
 
       const mentionedNewMembers = extractNewMentionedParentMembers(
         messageInfo.text,
         threadInfo,
         parentThreadInfo,
       );
 
       if (mentionedNewMembers.length === 0) {
         return;
       }
 
       const newMemberIDs = mentionedNewMembers.map(({ id }) => id);
-      const addMembersPromise = callChangeThreadSettings({
+      if (threadTypeIsThick(threadInfo.type)) {
+        await callAddDMThreadMembers(newMemberIDs, threadInfo);
+        return;
+      }
+
+      const changeThreadSettingsRequest = {
         threadID: threadInfo.id,
         changes: { newMemberIDs },
-      });
+      };
+
+      const changeThreadSettingsInput = {
+        thick: false,
+        ...changeThreadSettingsRequest,
+      };
+
+      const addMembersPromise = callChangeThreadSettings(
+        changeThreadSettingsInput,
+      );
 
       void dispatchActionPromise(
         changeThreadSettingsActionTypes,
         addMembersPromise,
       );
       await addMembersPromise;
     };
   },
 
   canBeSidebarSource: true,
 
   canBePinned: true,
 
   validator: rawTextMessageInfoValidator,
 });
diff --git a/lib/types/thread-types.js b/lib/types/thread-types.js
index 32913d522..af66b8d8a 100644
--- a/lib/types/thread-types.js
+++ b/lib/types/thread-types.js
@@ -1,519 +1,529 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import {
   type AvatarDBContent,
   type ClientAvatar,
   clientAvatarValidator,
   type UpdateUserAvatarRequest,
 } from './avatar-types.js';
 import type { CalendarQuery } from './entry-types.js';
 import type { Media } from './media-types.js';
 import type {
   MessageTruncationStatuses,
   RawMessageInfo,
 } from './message-types.js';
 import type {
   RawThreadInfo,
   ResolvedThreadInfo,
   ThreadInfo,
   ThickRawThreadInfo,
 } from './minimally-encoded-thread-permissions-types.js';
 import {
   type ThreadSubscription,
   threadSubscriptionValidator,
 } from './subscription-types.js';
 import {
   type ThreadPermissionsInfo,
   threadPermissionsInfoValidator,
   type ThreadRolePermissionsBlob,
   threadRolePermissionsBlobValidator,
   type UserSurfacedPermission,
 } from './thread-permission-types.js';
 import {
   type ThinThreadType,
   type ThickThreadType,
   threadTypeValidator,
 } from './thread-types-enum.js';
 import type { ClientUpdateInfo, ServerUpdateInfo } from './update-types.js';
 import type { UserInfo, UserInfos } from './user-types.js';
 import type { SpecialRole } from '../permissions/special-roles.js';
 import { type ThreadEntity } from '../utils/entity-text.js';
 import { tID, tShape, tUserID } from '../utils/validation-utils.js';
 
 export type LegacyMemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +isSender: boolean,
 };
 export const legacyMemberInfoValidator: TInterface<LegacyMemberInfo> =
   tShape<LegacyMemberInfo>({
     id: tUserID,
     role: t.maybe(tID),
     permissions: threadPermissionsInfoValidator,
     isSender: t.Boolean,
   });
 
 export type ClientLegacyRoleInfo = {
   +id: string,
   +name: string,
   +permissions: ThreadRolePermissionsBlob,
   +isDefault: boolean,
 };
 export const clientLegacyRoleInfoValidator: TInterface<ClientLegacyRoleInfo> =
   tShape<ClientLegacyRoleInfo>({
     id: tID,
     name: t.String,
     permissions: threadRolePermissionsBlobValidator,
     isDefault: t.Boolean,
   });
 
 export type ServerLegacyRoleInfo = {
   +id: string,
   +name: string,
   +permissions: ThreadRolePermissionsBlob,
   +isDefault: boolean,
   +specialRole: ?SpecialRole,
 };
 
 export type LegacyThreadCurrentUserInfo = {
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +unread: ?boolean,
 };
 export const legacyThreadCurrentUserInfoValidator: TInterface<LegacyThreadCurrentUserInfo> =
   tShape<LegacyThreadCurrentUserInfo>({
     role: t.maybe(tID),
     permissions: threadPermissionsInfoValidator,
     subscription: threadSubscriptionValidator,
     unread: t.maybe(t.Boolean),
   });
 
 export type LegacyThinRawThreadInfo = {
   +id: string,
   +type: ThinThreadType,
   +name?: ?string,
   +avatar?: ?ClientAvatar,
   +description?: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID: ?string,
   +containingThreadID?: ?string,
   +community: ?string,
   +members: $ReadOnlyArray<LegacyMemberInfo>,
   +roles: { +[id: string]: ClientLegacyRoleInfo },
   +currentUser: LegacyThreadCurrentUserInfo,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
 };
 
 export type ThickMemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +isSender: boolean,
 };
 
 export type ThreadTimestamps = {
   +name: number,
   +avatar: number,
   +description: number,
   +color: number,
   +members: {
     +[id: string]: {
       +isMember: number,
       +subscription: number,
     },
   },
   +currentUser: {
     +unread: number,
   },
 };
 
 export const threadTimestampsValidator: TInterface<ThreadTimestamps> =
   tShape<ThreadTimestamps>({
     name: t.Number,
     avatar: t.Number,
     description: t.Number,
     color: t.Number,
     members: t.dict(
       tUserID,
       tShape({
         isMember: t.Number,
         subscription: t.Number,
       }),
     ),
     currentUser: tShape({
       unread: t.Number,
     }),
   });
 
 export type LegacyThickRawThreadInfo = {
   +thick: true,
   +id: string,
   +type: ThickThreadType,
   +name?: ?string,
   +avatar?: ?ClientAvatar,
   +description?: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID?: ?string,
   +containingThreadID?: ?string,
   +members: $ReadOnlyArray<ThickMemberInfo>,
   +roles: { +[id: string]: ClientLegacyRoleInfo },
   +currentUser: LegacyThreadCurrentUserInfo,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
   +timestamps: ThreadTimestamps,
 };
 
 export type LegacyRawThreadInfo =
   | LegacyThinRawThreadInfo
   | LegacyThickRawThreadInfo;
 
 export type LegacyRawThreadInfos = {
   +[id: string]: LegacyRawThreadInfo,
 };
 export const legacyRawThreadInfoValidator: TInterface<LegacyRawThreadInfo> =
   tShape<LegacyRawThreadInfo>({
     id: tID,
     type: threadTypeValidator,
     name: t.maybe(t.String),
     avatar: t.maybe(clientAvatarValidator),
     description: t.maybe(t.String),
     color: t.String,
     creationTime: t.Number,
     parentThreadID: t.maybe(tID),
     containingThreadID: t.maybe(tID),
     community: t.maybe(tID),
     members: t.list(legacyMemberInfoValidator),
     roles: t.dict(tID, clientLegacyRoleInfoValidator),
     currentUser: legacyThreadCurrentUserInfoValidator,
     sourceMessageID: t.maybe(tID),
     repliesCount: t.Number,
     pinnedCount: t.maybe(t.Number),
   });
 
 export type MixedRawThreadInfos = {
   +[id: string]: LegacyRawThreadInfo | RawThreadInfo,
 };
 export type ThickRawThreadInfos = {
   +[id: string]: ThickRawThreadInfo,
 };
 export type RawThreadInfos = {
   +[id: string]: RawThreadInfo,
 };
 
 export type ServerMemberInfo = {
   +id: string,
   +role: ?string,
   +permissions: ThreadPermissionsInfo,
   +subscription: ThreadSubscription,
   +unread: ?boolean,
   +isSender: boolean,
 };
 
 export type ServerThreadInfo = {
   +id: string,
   +type: ThinThreadType,
   +name: ?string,
   +avatar?: AvatarDBContent,
   +description: ?string,
   +color: string, // hex, without "#" or "0x"
   +creationTime: number, // millisecond timestamp
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +depth: number,
   +members: $ReadOnlyArray<ServerMemberInfo>,
   +roles: { +[id: string]: ServerLegacyRoleInfo },
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount: number,
 };
 
 export type LegacyThreadStore = {
   +threadInfos: MixedRawThreadInfos,
 };
 
 export type ThreadStore = {
   +threadInfos: RawThreadInfos,
 };
 
 export type ClientDBThreadInfo = {
   +id: string,
   +type: number,
   +name: ?string,
   +avatar?: ?string,
   +description: ?string,
   +color: string,
   +creationTime: string,
   +parentThreadID: ?string,
   +containingThreadID: ?string,
   +community: ?string,
   +members: string,
   +roles: string,
   +currentUser: string,
   +sourceMessageID?: string,
   +repliesCount: number,
   +pinnedCount?: number,
   +timestamps?: ?string,
 };
 
 export type ThreadDeletionRequest = {
   +threadID: string,
   +accountPassword?: empty,
 };
 
 export type RemoveMembersRequest = {
   +threadID: string,
   +memberIDs: $ReadOnlyArray<string>,
 };
 
 export type RoleChangeRequest = {
   +threadID: string,
   +memberIDs: $ReadOnlyArray<string>,
   +role: string,
 };
 
 export type ChangeThreadSettingsResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
 };
 
 export type ChangeThreadSettingsPayload = {
   +threadID: string,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
 };
 
 export type LeaveThreadRequest = {
   +threadID: string,
 };
 export type LeaveThreadResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
 };
 
 export type LeaveThreadPayload = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
 };
 
-export type ThreadChanges = Partial<{
+type BaseThreadChanges = {
   +type: ThinThreadType,
   +name: string,
   +description: string,
   +color: string,
   +parentThreadID: ?string,
-  +newMemberIDs: $ReadOnlyArray<string>,
   +avatar: UpdateUserAvatarRequest,
-}>;
+};
+
+export type ThreadChanges = Partial<BaseThreadChanges>;
+
+export type ThinThreadChanges = $ReadOnly<
+  $Partial<{ ...BaseThreadChanges, +newMemberIDs: $ReadOnlyArray<string> }>,
+>;
 
 export type UpdateThreadRequest = {
   +threadID: string,
-  +changes: ThreadChanges,
+  +changes: ThinThreadChanges,
   +accountPassword?: empty,
 };
 
+export type UpdateThickThreadRequest = $ReadOnly<{
+  ...UpdateThreadRequest,
+  +changes: ThreadChanges,
+}>;
+
 export type BaseNewThreadRequest = {
   +id?: ?string,
   +name?: ?string,
   +description?: ?string,
   +color?: ?string,
   +parentThreadID?: ?string,
   +initialMemberIDs?: ?$ReadOnlyArray<string>,
   +ghostMemberIDs?: ?$ReadOnlyArray<string>,
 };
 type NewThinThreadRequest =
   | $ReadOnly<{
       +type: 3 | 4 | 6 | 7 | 8 | 9 | 10 | 11 | 12,
       ...BaseNewThreadRequest,
     }>
   | $ReadOnly<{
       +type: 5,
       +sourceMessageID: string,
       ...BaseNewThreadRequest,
       +parentThreadID: string,
     }>;
 
 export type ClientNewThinThreadRequest = $ReadOnly<{
   ...NewThinThreadRequest,
   +calendarQuery: CalendarQuery,
 }>;
 export type ServerNewThinThreadRequest = $ReadOnly<{
   ...NewThinThreadRequest,
   +calendarQuery?: ?CalendarQuery,
 }>;
 
 export type NewThickThreadRequest =
   | $ReadOnly<{
       +type: 13 | 14 | 15,
       ...BaseNewThreadRequest,
     }>
   | $ReadOnly<{
       +type: 16,
       +sourceMessageID: string,
       ...BaseNewThreadRequest,
       +parentThreadID: string,
     }>;
 
 export type NewThreadResponse = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +userInfos: UserInfos,
   +newThreadID: string,
 };
 export type NewThreadResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +userInfos: UserInfos,
   +newThreadID: string,
 };
 
 export type ServerThreadJoinRequest = {
   +threadID: string,
   +calendarQuery?: ?CalendarQuery,
   +inviteLinkSecret?: string,
   +defaultSubscription?: ThreadSubscription,
 };
 export type ClientThreadJoinRequest = {
   +threadID: string,
   +calendarQuery: CalendarQuery,
   +inviteLinkSecret?: string,
   +defaultSubscription?: ThreadSubscription,
 };
 export type ThreadJoinResult = {
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: UserInfos,
 };
 export type ThreadJoinPayload = {
   +updatesResult: {
     newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatuses: MessageTruncationStatuses,
   +userInfos: $ReadOnlyArray<UserInfo>,
   +keyserverID?: string,
 };
 
 export type ThreadFetchMediaResult = {
   +media: $ReadOnlyArray<Media>,
 };
 export type ThreadFetchMediaRequest = {
   +threadID: string,
   +limit: number,
   +offset: number,
 };
 
 export type SidebarInfo = {
   +threadInfo: ThreadInfo,
   +lastUpdatedTime: number,
   +mostRecentNonLocalMessage: ?string,
 };
 
 export type ToggleMessagePinRequest = {
   +messageID: string,
   +action: 'pin' | 'unpin',
 };
 
 export type ToggleMessagePinResult = {
   +newMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +threadID: string,
 };
 
 type CreateRoleAction = {
   +community: string,
   +name: string,
   +permissions: $ReadOnlyArray<UserSurfacedPermission>,
   +action: 'create_role',
 };
 
 type EditRoleAction = {
   +community: string,
   +existingRoleID: string,
   +name: string,
   +permissions: $ReadOnlyArray<UserSurfacedPermission>,
   +action: 'edit_role',
 };
 
 export type RoleModificationRequest = CreateRoleAction | EditRoleAction;
 
 export type RoleModificationResult = {
   +threadInfo: LegacyRawThreadInfo | RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
 };
 
 export type RoleModificationPayload = {
   +threadInfo: LegacyRawThreadInfo | RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
 };
 
 export type RoleDeletionRequest = {
   +community: string,
   +roleID: string,
 };
 
 export type RoleDeletionResult = {
   +threadInfo: LegacyRawThreadInfo | RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   },
 };
 
 export type RoleDeletionPayload = {
   +threadInfo: LegacyRawThreadInfo | RawThreadInfo,
   +updatesResult: {
     +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   },
 };
 
 // We can show a max of 3 sidebars inline underneath their parent in the chat
 // tab. If there are more, we show a button that opens a modal to see the rest
 export const maxReadSidebars = 3;
 
 // We can show a max of 5 sidebars inline underneath their parent
 // in the chat tab if every one of the displayed sidebars is unread
 export const maxUnreadSidebars = 5;
 
 export type ThreadStoreThreadInfos = LegacyRawThreadInfos;
 
 export type ChatMentionCandidate = {
   +threadInfo: ResolvedThreadInfo,
   +rawChatName: string | ThreadEntity,
 };
 export type ChatMentionCandidates = {
   +[id: string]: ChatMentionCandidate,
 };
 export type ChatMentionCandidatesObj = {
   +[id: string]: ChatMentionCandidates,
 };
 
 export type UserProfileThreadInfo = {
   +threadInfo: ThreadInfo,
   +pendingPersonalThreadUserInfo?: UserInfo,
 };
diff --git a/native/chat/settings/add-users-modal.react.js b/native/chat/settings/add-users-modal.react.js
index c7703da12..008d2a0ac 100644
--- a/native/chat/settings/add-users-modal.react.js
+++ b/native/chat/settings/add-users-modal.react.js
@@ -1,302 +1,303 @@
 // @flow
 
 import * as React from 'react';
 import { ActivityIndicator, Text, View } from 'react-native';
 
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
 } from 'lib/actions/thread-actions.js';
 import { useENSNames } from 'lib/hooks/ens-cache.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors.js';
 import { userInfoSelectorForPotentialMembers } from 'lib/selectors/user-selectors.js';
 import { useAddDMThreadMembers } from 'lib/shared/dm-ops/dm-op-utils.js';
 import { usePotentialMemberItems } from 'lib/shared/search-utils.js';
 import { threadActualMembers } from 'lib/shared/thread-utils.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
 import { threadTypeIsThick } from 'lib/types/thread-types-enum.js';
 import { type AccountUserInfo } from 'lib/types/user-types.js';
 import { useDispatchActionPromise } from 'lib/utils/redux-promise-utils.js';
 
 import Button from '../../components/button.react.js';
 import Modal from '../../components/modal.react.js';
 import {
   type BaseTagInput,
   createTagInput,
 } from '../../components/tag-input.react.js';
 import UserList from '../../components/user-list.react.js';
 import type { RootNavigationProp } from '../../navigation/root-navigator.react.js';
 import type { NavigationRoute } from '../../navigation/route-names.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { useStyles } from '../../themes/colors.js';
 import { unknownErrorAlertDetails } from '../../utils/alert-messages.js';
 import Alert from '../../utils/alert.js';
 
 const TagInput = createTagInput<AccountUserInfo>();
 
 const tagInputProps = {
   placeholder: 'Select users to add',
   autoFocus: true,
   returnKeyType: 'go',
 };
 
 const tagDataLabelExtractor = (userInfo: AccountUserInfo) => userInfo.username;
 
 export type AddUsersModalParams = {
   +presentedFrom: string,
   +threadInfo: ThreadInfo,
 };
 
 type Props = {
   +navigation: RootNavigationProp<'AddUsersModal'>,
   +route: NavigationRoute<'AddUsersModal'>,
 };
 function AddUsersModal(props: Props): React.Node {
   const [usernameInputText, setUsernameInputText] = React.useState<string>('');
   const [userInfoInputArray, setUserInfoInputArray] = React.useState<
     $ReadOnlyArray<AccountUserInfo>,
   >([]);
 
   const tagInputRef = React.useRef<?BaseTagInput<AccountUserInfo>>();
   const onUnknownErrorAlertAcknowledged = React.useCallback(() => {
     setUsernameInputText('');
     setUserInfoInputArray([]);
     tagInputRef.current?.focus();
   }, []);
 
   const { navigation } = props;
   const { goBackOnce } = navigation;
   const close = React.useCallback(() => {
     goBackOnce();
   }, [goBackOnce]);
 
   const callChangeThreadSettings = useChangeThreadSettings();
   const userInfoInputIDs = userInfoInputArray.map(userInfo => userInfo.id);
   const { route } = props;
   const { threadInfo } = route.params;
   const threadID = threadInfo.id;
   const addUsersToThread = React.useCallback(async () => {
     try {
       const result = await callChangeThreadSettings({
+        thick: false,
         threadID: threadID,
         changes: { newMemberIDs: userInfoInputIDs },
       });
       close();
       return result;
     } catch (e) {
       Alert.alert(
         unknownErrorAlertDetails.title,
         unknownErrorAlertDetails.message,
         [{ text: 'OK', onPress: onUnknownErrorAlertAcknowledged }],
         { cancelable: false },
       );
       throw e;
     }
   }, [
     callChangeThreadSettings,
     threadID,
     userInfoInputIDs,
     close,
     onUnknownErrorAlertAcknowledged,
   ]);
 
   const inputLength = userInfoInputArray.length;
   const dispatchActionPromise = useDispatchActionPromise();
   const userInfoInputArrayEmpty = inputLength === 0;
   const addDMThreadMembers = useAddDMThreadMembers();
 
   const onPressAdd = React.useCallback(() => {
     if (userInfoInputArrayEmpty) {
       return;
     }
 
     if (threadTypeIsThick(threadInfo.type)) {
       void addDMThreadMembers(userInfoInputIDs, threadInfo);
     } else {
       void dispatchActionPromise(
         changeThreadSettingsActionTypes,
         addUsersToThread(),
       );
     }
   }, [
     userInfoInputArrayEmpty,
     threadInfo,
     dispatchActionPromise,
     addUsersToThread,
     addDMThreadMembers,
     userInfoInputIDs,
   ]);
 
   const changeThreadSettingsLoadingStatus = useSelector(
     createLoadingStatusSelector(changeThreadSettingsActionTypes),
   );
   const isLoading = changeThreadSettingsLoadingStatus === 'loading';
 
   const styles = useStyles(unboundStyles);
 
   let addButton = null;
   if (inputLength > 0) {
     let activityIndicator = null;
     if (isLoading) {
       activityIndicator = (
         <View style={styles.activityIndicator}>
           <ActivityIndicator color="white" />
         </View>
       );
     }
     const addButtonText = `Add (${inputLength})`;
     addButton = (
       <Button
         onPress={onPressAdd}
         style={styles.addButton}
         disabled={isLoading}
       >
         {activityIndicator}
         <Text style={styles.addText}>{addButtonText}</Text>
       </Button>
     );
   }
 
   let cancelButton;
   if (!isLoading) {
     cancelButton = (
       <Button onPress={close} style={styles.cancelButton}>
         <Text style={styles.cancelText}>Cancel</Text>
       </Button>
     );
   } else {
     cancelButton = <View />;
   }
 
   const threadMemberIDs = React.useMemo(
     () => threadActualMembers(threadInfo.members),
     [threadInfo.members],
   );
   const excludeUserIDs = React.useMemo(
     () => userInfoInputIDs.concat(threadMemberIDs),
     [userInfoInputIDs, threadMemberIDs],
   );
 
   const otherUserInfos = useSelector(userInfoSelectorForPotentialMembers);
   const { parentThreadID, community } = props.route.params.threadInfo;
   const parentThreadInfo = useSelector(state =>
     parentThreadID ? threadInfoSelector(state)[parentThreadID] : null,
   );
   const communityThreadInfo = useSelector(state =>
     community ? threadInfoSelector(state)[community] : null,
   );
   const userSearchResults = usePotentialMemberItems({
     text: usernameInputText,
     userInfos: otherUserInfos,
     excludeUserIDs,
     inputParentThreadInfo: parentThreadInfo,
     inputCommunityThreadInfo: communityThreadInfo,
     threadType: threadInfo.type,
   });
 
   const onChangeTagInput = React.useCallback(
     (newUserInfoInputArray: $ReadOnlyArray<AccountUserInfo>) => {
       if (!isLoading) {
         setUserInfoInputArray(newUserInfoInputArray);
       }
     },
     [isLoading],
   );
 
   const onChangeTagInputText = React.useCallback(
     (text: string) => {
       if (!isLoading) {
         setUsernameInputText(text);
       }
     },
     [isLoading],
   );
 
   const onUserSelect = React.useCallback(
     ({ id }: AccountUserInfo) => {
       if (isLoading) {
         return;
       }
       if (userInfoInputIDs.some(existingUserID => id === existingUserID)) {
         return;
       }
       setUserInfoInputArray(oldUserInfoInputArray => [
         ...oldUserInfoInputArray,
         otherUserInfos[id],
       ]);
       setUsernameInputText('');
     },
     [isLoading, userInfoInputIDs, otherUserInfos],
   );
 
   const inputProps = React.useMemo(
     () => ({
       ...tagInputProps,
       onSubmitEditing: onPressAdd,
     }),
     [onPressAdd],
   );
   const userSearchResultWithENSNames = useENSNames(userSearchResults);
   const userInfoInputArrayWithENSNames = useENSNames(userInfoInputArray);
   return (
     <Modal>
       <TagInput
         value={userInfoInputArrayWithENSNames}
         onChange={onChangeTagInput}
         text={usernameInputText}
         onChangeText={onChangeTagInputText}
         labelExtractor={tagDataLabelExtractor}
         defaultInputWidth={160}
         maxHeight={36}
         inputProps={inputProps}
         ref={tagInputRef}
       />
       <UserList
         userInfos={userSearchResultWithENSNames}
         onSelect={onUserSelect}
       />
       <View style={styles.buttons}>
         {cancelButton}
         {addButton}
       </View>
     </Modal>
   );
 }
 
 const unboundStyles = {
   activityIndicator: {
     paddingRight: 6,
   },
   addButton: {
     backgroundColor: 'vibrantGreenButton',
     borderRadius: 3,
     flexDirection: 'row',
     paddingHorizontal: 10,
     paddingVertical: 4,
   },
   addText: {
     color: 'white',
     fontSize: 18,
   },
   buttons: {
     flexDirection: 'row',
     justifyContent: 'space-between',
     marginTop: 12,
   },
   cancelButton: {
     backgroundColor: 'modalButton',
     borderRadius: 3,
     paddingHorizontal: 10,
     paddingVertical: 4,
   },
   cancelText: {
     color: 'modalButtonLabel',
     fontSize: 18,
   },
 };
 
 const MemoizedAddUsersModal: React.ComponentType<Props> =
   React.memo<Props>(AddUsersModal);
 
 export default MemoizedAddUsersModal;
diff --git a/native/chat/settings/color-selector-modal.react.js b/native/chat/settings/color-selector-modal.react.js
index e392c83e5..59f56d38a 100644
--- a/native/chat/settings/color-selector-modal.react.js
+++ b/native/chat/settings/color-selector-modal.react.js
@@ -1,195 +1,208 @@
 // @flow
 
 import Icon from '@expo/vector-icons/FontAwesome.js';
 import * as React from 'react';
 import { TouchableHighlight } from 'react-native';
 
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
+  type UseChangeThreadSettingsInput,
 } from 'lib/actions/thread-actions.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
-import {
-  type ChangeThreadSettingsPayload,
-  type UpdateThreadRequest,
-} from 'lib/types/thread-types.js';
+import { threadTypeIsThick } from 'lib/types/thread-types-enum.js';
+import { type ChangeThreadSettingsPayload } from 'lib/types/thread-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/redux-promise-utils.js';
 
 import ColorSelector from '../../components/color-selector.react.js';
 import Modal from '../../components/modal.react.js';
 import type { RootNavigationProp } from '../../navigation/root-navigator.react.js';
 import type { NavigationRoute } from '../../navigation/route-names.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { type Colors, useColors, useStyles } from '../../themes/colors.js';
 import { unknownErrorAlertDetails } from '../../utils/alert-messages.js';
 import Alert from '../../utils/alert.js';
 
 export type ColorSelectorModalParams = {
   +presentedFrom: string,
   +color: string,
   +threadInfo: ThreadInfo,
   +setColor: (color: string) => void,
 };
 
 const unboundStyles = {
   closeButton: {
     borderRadius: 3,
     height: 18,
     position: 'absolute',
     right: 5,
     top: 5,
     width: 18,
   },
   closeButtonIcon: {
     color: 'modalBackgroundSecondaryLabel',
     left: 3,
     position: 'absolute',
   },
   colorSelector: {
     bottom: 10,
     left: 10,
     position: 'absolute',
     right: 10,
     top: 10,
   },
   colorSelectorContainer: {
     backgroundColor: 'modalBackground',
     borderRadius: 5,
     flex: 0,
     marginHorizontal: 15,
     marginVertical: 20,
   },
 };
 
 type BaseProps = {
   +navigation: RootNavigationProp<'ColorSelectorModal'>,
   +route: NavigationRoute<'ColorSelectorModal'>,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
   +windowWidth: number,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +changeThreadSettings: (
-    request: UpdateThreadRequest,
+    input: UseChangeThreadSettingsInput,
   ) => Promise<ChangeThreadSettingsPayload>,
 };
 function ColorSelectorModal(props: Props): React.Node {
   const {
     changeThreadSettings: updateThreadSettings,
     dispatchActionPromise,
     windowWidth,
   } = props;
   const { threadInfo, setColor } = props.route.params;
 
   const close = props.navigation.goBackOnce;
 
   const onErrorAcknowledged = React.useCallback(() => {
     setColor(threadInfo.color);
   }, [setColor, threadInfo.color]);
 
   const editColor = React.useCallback(
     async (newColor: string) => {
       const threadID = threadInfo.id;
       try {
-        return await updateThreadSettings({
+        const changeThreadSettingRequest = {
           threadID,
           changes: { color: newColor },
-        });
+        };
+
+        const changeThreadSettingInput = threadTypeIsThick(
+          props.route.params.threadInfo.type,
+        )
+          ? {
+              thick: true,
+              threadInfo: props.route.params.threadInfo,
+              ...changeThreadSettingRequest,
+            }
+          : { thick: false, ...changeThreadSettingRequest };
+        return await updateThreadSettings(changeThreadSettingInput);
       } catch (e) {
         Alert.alert(
           unknownErrorAlertDetails.title,
           unknownErrorAlertDetails.message,
           [{ text: 'OK', onPress: onErrorAcknowledged }],
           { cancelable: false },
         );
         throw e;
       }
     },
-    [onErrorAcknowledged, threadInfo.id, updateThreadSettings],
+    [
+      onErrorAcknowledged,
+      threadInfo.id,
+      updateThreadSettings,
+      props.route.params.threadInfo,
+    ],
   );
 
   const onColorSelected = React.useCallback(
     (color: string) => {
       const colorEditValue = color.substr(1);
       setColor(colorEditValue);
       close();
 
       const action = changeThreadSettingsActionTypes.started;
       const threadID = props.route.params.threadInfo.id;
       void dispatchActionPromise(
         changeThreadSettingsActionTypes,
         editColor(colorEditValue),
         {
           customKeyName: `${action}:${threadID}:color`,
         },
       );
     },
     [
       setColor,
       close,
       dispatchActionPromise,
       editColor,
       props.route.params.threadInfo.id,
     ],
   );
 
   const { colorSelectorContainer, closeButton, closeButtonIcon } = props.styles;
   // Based on the assumption we are always in portrait,
   // and consequently width is the lowest dimensions
   const modalStyle = React.useMemo(
     () => [colorSelectorContainer, { height: 0.75 * windowWidth }],
     [colorSelectorContainer, windowWidth],
   );
 
   const { modalIosHighlightUnderlay } = props.colors;
   const { color } = props.route.params;
   return (
     <Modal modalStyle={modalStyle}>
       <ColorSelector
         currentColor={color}
         windowWidth={windowWidth}
         onColorSelected={onColorSelected}
       />
       <TouchableHighlight
         onPress={close}
         style={closeButton}
         underlayColor={modalIosHighlightUnderlay}
       >
         <Icon name="close" size={16} style={closeButtonIcon} />
       </TouchableHighlight>
     </Modal>
   );
 }
 
 const ConnectedColorSelectorModal: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedColorSelectorModal(props: BaseProps) {
     const styles = useStyles(unboundStyles);
     const colors = useColors();
     const windowWidth = useSelector(state => state.dimensions.width);
 
     const dispatchActionPromise = useDispatchActionPromise();
-    const callChangeThreadSettings = useChangeThreadSettings(
-      props.route.params.threadInfo,
-    );
+    const callChangeThreadSettings = useChangeThreadSettings();
 
     return (
       <ColorSelectorModal
         {...props}
         styles={styles}
         colors={colors}
         windowWidth={windowWidth}
         dispatchActionPromise={dispatchActionPromise}
         changeThreadSettings={callChangeThreadSettings}
       />
     );
   });
 
 export default ConnectedColorSelectorModal;
diff --git a/native/chat/settings/thread-settings-description.react.js b/native/chat/settings/thread-settings-description.react.js
index 1f9d4434a..63dd9ad21 100644
--- a/native/chat/settings/thread-settings-description.react.js
+++ b/native/chat/settings/thread-settings-description.react.js
@@ -1,329 +1,340 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import {
   ActivityIndicator,
   Text,
   TextInput as BaseTextInput,
   View,
 } from 'react-native';
 
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
+  type UseChangeThreadSettingsInput,
 } from 'lib/actions/thread-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import { useThreadHasPermission } from 'lib/shared/thread-utils.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
-import {
-  type ChangeThreadSettingsPayload,
-  type UpdateThreadRequest,
-} from 'lib/types/thread-types.js';
+import { threadTypeIsThick } from 'lib/types/thread-types-enum.js';
+import { type ChangeThreadSettingsPayload } from 'lib/types/thread-types.js';
 import {
   type DispatchActionPromise,
   useDispatchActionPromise,
 } from 'lib/utils/redux-promise-utils.js';
 
 import SaveSettingButton from './save-setting-button.react.js';
 import {
   ThreadSettingsCategoryFooter,
   ThreadSettingsCategoryHeader,
 } from './thread-settings-category.react.js';
 import Button from '../../components/button.react.js';
 import EditSettingButton from '../../components/edit-setting-button.react.js';
 import SWMansionIcon from '../../components/swmansion-icon.react.js';
 import TextInput from '../../components/text-input.react.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { type Colors, useColors, useStyles } from '../../themes/colors.js';
 import type {
   ContentSizeChangeEvent,
   LayoutEvent,
 } from '../../types/react-native.js';
 import { unknownErrorAlertDetails } from '../../utils/alert-messages.js';
 import Alert from '../../utils/alert.js';
 
 const unboundStyles = {
   addDescriptionButton: {
     flexDirection: 'row',
     paddingHorizontal: 24,
     paddingVertical: 10,
   },
   addDescriptionText: {
     color: 'panelForegroundTertiaryLabel',
     flex: 1,
     fontSize: 16,
   },
   editIcon: {
     color: 'panelForegroundTertiaryLabel',
     paddingLeft: 10,
     textAlign: 'right',
   },
   outlineCategory: {
     backgroundColor: 'panelForeground',
     borderColor: 'panelForegroundBorder',
     borderRadius: 1,
     borderStyle: 'dashed',
     borderWidth: 1,
     marginLeft: -1,
     marginRight: -1,
   },
   row: {
     backgroundColor: 'panelForeground',
     flexDirection: 'row',
     paddingHorizontal: 24,
     paddingVertical: 4,
   },
   text: {
     color: 'panelForegroundSecondaryLabel',
     flex: 1,
     fontFamily: 'Arial',
     fontSize: 16,
     margin: 0,
     padding: 0,
     borderBottomColor: 'transparent',
   },
 };
 
 type BaseProps = {
   +threadInfo: ThreadInfo,
   +descriptionEditValue: ?string,
   +setDescriptionEditValue: (value: ?string, callback?: () => void) => void,
   +descriptionTextHeight: ?number,
   +setDescriptionTextHeight: (number: number) => void,
   +canChangeSettings: boolean,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +loadingStatus: LoadingStatus,
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +changeThreadSettings: (
-    update: UpdateThreadRequest,
+    input: UseChangeThreadSettingsInput,
   ) => Promise<ChangeThreadSettingsPayload>,
   +canEditThreadDescription: boolean,
 };
 class ThreadSettingsDescription extends React.PureComponent<Props> {
   textInput: ?React.ElementRef<typeof BaseTextInput>;
 
   render(): React.Node {
     if (
       this.props.descriptionEditValue !== null &&
       this.props.descriptionEditValue !== undefined
     ) {
       const textInputStyle: { height?: number } = {};
       if (
         this.props.descriptionTextHeight !== undefined &&
         this.props.descriptionTextHeight !== null
       ) {
         textInputStyle.height = this.props.descriptionTextHeight;
       }
       return (
         <View>
           <ThreadSettingsCategoryHeader type="full" title="Description" />
           <View style={this.props.styles.row}>
             <TextInput
               style={[this.props.styles.text, textInputStyle]}
               value={this.props.descriptionEditValue}
               onChangeText={this.props.setDescriptionEditValue}
               multiline={true}
               autoFocus={true}
               selectTextOnFocus={true}
               onBlur={this.onSubmit}
               editable={this.props.loadingStatus !== 'loading'}
               onContentSizeChange={this.onTextInputContentSizeChange}
               ref={this.textInputRef}
               selectionColor={`#${this.props.threadInfo.color}`}
             />
             {this.renderButton()}
           </View>
           <ThreadSettingsCategoryFooter type="full" />
         </View>
       );
     }
 
     if (this.props.threadInfo.description) {
       return (
         <View>
           <ThreadSettingsCategoryHeader type="full" title="Description" />
           <View style={this.props.styles.row}>
             <Text style={this.props.styles.text} onLayout={this.onLayoutText}>
               {this.props.threadInfo.description}
             </Text>
             {this.renderButton()}
           </View>
           <ThreadSettingsCategoryFooter type="full" />
         </View>
       );
     }
 
     const { panelIosHighlightUnderlay } = this.props.colors;
     if (this.props.canEditThreadDescription) {
       return (
         <View>
           <ThreadSettingsCategoryHeader type="outline" title="Description" />
           <View style={this.props.styles.outlineCategory}>
             <Button
               onPress={this.onPressEdit}
               style={this.props.styles.addDescriptionButton}
               iosFormat="highlight"
               iosHighlightUnderlayColor={panelIosHighlightUnderlay}
               iosActiveOpacity={0.85}
             >
               <Text style={this.props.styles.addDescriptionText}>
                 Add a description...
               </Text>
               <SWMansionIcon
                 name="edit-1"
                 size={20}
                 style={this.props.styles.editIcon}
               />
             </Button>
           </View>
           <ThreadSettingsCategoryFooter type="outline" />
         </View>
       );
     }
 
     return null;
   }
 
   renderButton(): React.Node {
     if (this.props.loadingStatus === 'loading') {
       return (
         <ActivityIndicator
           size="small"
           color={this.props.colors.panelForegroundSecondaryLabel}
         />
       );
     } else if (
       this.props.descriptionEditValue === null ||
       this.props.descriptionEditValue === undefined
     ) {
       return (
         <EditSettingButton
           onPress={this.onPressEdit}
           canChangeSettings={this.props.canChangeSettings}
         />
       );
     }
     return <SaveSettingButton onPress={this.onSubmit} />;
   }
 
   textInputRef = (textInput: ?React.ElementRef<typeof BaseTextInput>) => {
     this.textInput = textInput;
   };
 
   onLayoutText = (event: LayoutEvent) => {
     this.props.setDescriptionTextHeight(event.nativeEvent.layout.height);
   };
 
   onTextInputContentSizeChange = (event: ContentSizeChangeEvent) => {
     this.props.setDescriptionTextHeight(event.nativeEvent.contentSize.height);
   };
 
   onPressEdit = () => {
     this.props.setDescriptionEditValue(this.props.threadInfo.description);
   };
 
   onSubmit = () => {
     invariant(
       this.props.descriptionEditValue !== null &&
         this.props.descriptionEditValue !== undefined,
       'should be set',
     );
     const description = this.props.descriptionEditValue.trim();
 
     if (description === this.props.threadInfo.description) {
       this.props.setDescriptionEditValue(null);
       return;
     }
 
     const editDescriptionPromise = this.editDescription(description);
     const action = changeThreadSettingsActionTypes.started;
     const threadID = this.props.threadInfo.id;
 
     void this.props.dispatchActionPromise(
       changeThreadSettingsActionTypes,
       editDescriptionPromise,
       {
         customKeyName: `${action}:${threadID}:description`,
       },
     );
     void editDescriptionPromise.then(() => {
       this.props.setDescriptionEditValue(null);
     });
   };
 
   async editDescription(
     newDescription: string,
   ): Promise<ChangeThreadSettingsPayload> {
     try {
-      return await this.props.changeThreadSettings({
+      const changeThreadSettingsRequest = {
         threadID: this.props.threadInfo.id,
         changes: { description: newDescription },
-      });
+      };
+
+      const changeThreadSettingsInput = threadTypeIsThick(
+        this.props.threadInfo.type,
+      )
+        ? {
+            thick: true,
+            threadInfo: this.props.threadInfo,
+            ...changeThreadSettingsRequest,
+          }
+        : { thick: false, ...changeThreadSettingsRequest };
+
+      return await this.props.changeThreadSettings(changeThreadSettingsInput);
     } catch (e) {
       Alert.alert(
         unknownErrorAlertDetails.title,
         unknownErrorAlertDetails.message,
         [{ text: 'OK', onPress: this.onErrorAcknowledged }],
         { cancelable: false },
       );
       throw e;
     }
   }
 
   onErrorAcknowledged = () => {
     this.props.setDescriptionEditValue(
       this.props.threadInfo.description,
       () => {
         invariant(this.textInput, 'textInput should be set');
         this.textInput.focus();
       },
     );
   };
 }
 
 const ConnectedThreadSettingsDescription: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedThreadSettingsDescription(
     props: BaseProps,
   ) {
     const threadID = props.threadInfo.id;
     const loadingStatus = useSelector(
       createLoadingStatusSelector(
         changeThreadSettingsActionTypes,
         `${changeThreadSettingsActionTypes.started}:${threadID}:description`,
       ),
     );
     const colors = useColors();
     const styles = useStyles(unboundStyles);
 
     const dispatchActionPromise = useDispatchActionPromise();
-    const callChangeThreadSettings = useChangeThreadSettings(props.threadInfo);
+    const callChangeThreadSettings = useChangeThreadSettings();
 
     const canEditThreadDescription = useThreadHasPermission(
       props.threadInfo,
       threadPermissions.EDIT_THREAD_DESCRIPTION,
     );
 
     return (
       <ThreadSettingsDescription
         {...props}
         loadingStatus={loadingStatus}
         colors={colors}
         styles={styles}
         dispatchActionPromise={dispatchActionPromise}
         changeThreadSettings={callChangeThreadSettings}
         canEditThreadDescription={canEditThreadDescription}
       />
     );
   });
 
 export default ConnectedThreadSettingsDescription;
diff --git a/native/chat/settings/thread-settings-name.react.js b/native/chat/settings/thread-settings-name.react.js
index 1bdfe921d..2626839b2 100644
--- a/native/chat/settings/thread-settings-name.react.js
+++ b/native/chat/settings/thread-settings-name.react.js
@@ -1,247 +1,258 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import {
   Text,
   ActivityIndicator,
   TextInput as BaseTextInput,
   View,
 } from 'react-native';
 
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
+  type UseChangeThreadSettingsInput,
 } from 'lib/actions/thread-actions.js';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors.js';
 import type { LoadingStatus } from 'lib/types/loading-types.js';
 import type { ResolvedThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
-import type {
-  ChangeThreadSettingsPayload,
-  UpdateThreadRequest,
-} from 'lib/types/thread-types.js';
+import { threadTypeIsThick } from 'lib/types/thread-types-enum.js';
+import type { ChangeThreadSettingsPayload } from 'lib/types/thread-types.js';
 import {
   useDispatchActionPromise,
   type DispatchActionPromise,
 } from 'lib/utils/redux-promise-utils.js';
 import { firstLine } from 'lib/utils/string-utils.js';
 import { chatNameMaxLength } from 'lib/utils/validation-utils.js';
 
 import SaveSettingButton from './save-setting-button.react.js';
 import EditSettingButton from '../../components/edit-setting-button.react.js';
 import SingleLine from '../../components/single-line.react.js';
 import TextInput from '../../components/text-input.react.js';
 import { useSelector } from '../../redux/redux-utils.js';
 import { type Colors, useStyles, useColors } from '../../themes/colors.js';
 import { unknownErrorAlertDetails } from '../../utils/alert-messages.js';
 import Alert from '../../utils/alert.js';
 
 const unboundStyles = {
   currentValue: {
     color: 'panelForegroundSecondaryLabel',
     flex: 1,
     fontFamily: 'Arial',
     fontSize: 16,
     margin: 0,
     paddingLeft: 4,
     paddingRight: 0,
     paddingVertical: 0,
     borderBottomColor: 'transparent',
   },
   label: {
     color: 'panelForegroundTertiaryLabel',
     fontSize: 16,
     width: 96,
   },
   row: {
     backgroundColor: 'panelForeground',
     flexDirection: 'row',
     paddingHorizontal: 24,
     paddingVertical: 8,
   },
 };
 
 type BaseProps = {
   +threadInfo: ResolvedThreadInfo,
   +nameEditValue: ?string,
   +setNameEditValue: (value: ?string, callback?: () => void) => void,
   +canChangeSettings: boolean,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +loadingStatus: LoadingStatus,
   +colors: Colors,
   +styles: $ReadOnly<typeof unboundStyles>,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +changeThreadSettings: (
-    update: UpdateThreadRequest,
+    input: UseChangeThreadSettingsInput,
   ) => Promise<ChangeThreadSettingsPayload>,
 };
 class ThreadSettingsName extends React.PureComponent<Props> {
   textInput: ?React.ElementRef<typeof BaseTextInput>;
 
   render(): React.Node {
     return (
       <View style={this.props.styles.row}>
         <Text style={this.props.styles.label}>Name</Text>
         {this.renderContent()}
       </View>
     );
   }
 
   renderButton(): React.Node {
     if (this.props.loadingStatus === 'loading') {
       return (
         <ActivityIndicator
           size="small"
           color={this.props.colors.panelForegroundSecondaryLabel}
         />
       );
     } else if (
       this.props.nameEditValue === null ||
       this.props.nameEditValue === undefined
     ) {
       return (
         <EditSettingButton
           onPress={this.onPressEdit}
           canChangeSettings={this.props.canChangeSettings}
         />
       );
     }
     return <SaveSettingButton onPress={this.onSubmit} />;
   }
 
   renderContent(): React.Node {
     if (
       this.props.nameEditValue === null ||
       this.props.nameEditValue === undefined
     ) {
       return (
         <React.Fragment>
           <SingleLine style={this.props.styles.currentValue}>
             {this.props.threadInfo.uiName}
           </SingleLine>
           {this.renderButton()}
         </React.Fragment>
       );
     }
 
     return (
       <React.Fragment>
         <TextInput
           style={this.props.styles.currentValue}
           value={this.props.nameEditValue}
           onChangeText={this.props.setNameEditValue}
           autoFocus={true}
           selectTextOnFocus={true}
           onBlur={this.onSubmit}
           editable={this.props.loadingStatus !== 'loading'}
           ref={this.textInputRef}
           selectionColor={`#${this.props.threadInfo.color}`}
           maxLength={chatNameMaxLength}
         />
         {this.renderButton()}
       </React.Fragment>
     );
   }
 
   textInputRef = (textInput: ?React.ElementRef<typeof BaseTextInput>) => {
     this.textInput = textInput;
   };
 
   threadEditName(): string {
     return firstLine(
       this.props.threadInfo.name ? this.props.threadInfo.name : '',
     );
   }
 
   onPressEdit = () => {
     this.props.setNameEditValue(this.threadEditName());
   };
 
   onSubmit = () => {
     invariant(
       this.props.nameEditValue !== null &&
         this.props.nameEditValue !== undefined,
       'should be set',
     );
     const name = firstLine(this.props.nameEditValue);
 
     if (name === this.threadEditName()) {
       this.props.setNameEditValue(null);
       return;
     }
 
     const editNamePromise = this.editName(name);
     const action = changeThreadSettingsActionTypes.started;
     const threadID = this.props.threadInfo.id;
 
     void this.props.dispatchActionPromise(
       changeThreadSettingsActionTypes,
       editNamePromise,
       {
         customKeyName: `${action}:${threadID}:name`,
       },
     );
     void editNamePromise.then(() => {
       this.props.setNameEditValue(null);
     });
   };
 
   async editName(newName: string): Promise<ChangeThreadSettingsPayload> {
     try {
-      return await this.props.changeThreadSettings({
+      const changeThreadSetingsRequest = {
         threadID: this.props.threadInfo.id,
         changes: { name: newName },
-      });
+      };
+
+      const changeThreadSettingsInput = threadTypeIsThick(
+        this.props.threadInfo.type,
+      )
+        ? {
+            thick: true,
+            threadInfo: this.props.threadInfo,
+            ...changeThreadSetingsRequest,
+          }
+        : { thick: false, ...changeThreadSetingsRequest };
+
+      return await this.props.changeThreadSettings(changeThreadSettingsInput);
     } catch (e) {
       Alert.alert(
         unknownErrorAlertDetails.title,
         unknownErrorAlertDetails.message,
         [{ text: 'OK', onPress: this.onErrorAcknowledged }],
         { cancelable: false },
       );
       throw e;
     }
   }
 
   onErrorAcknowledged = () => {
     this.props.setNameEditValue(this.threadEditName(), () => {
       invariant(this.textInput, 'textInput should be set');
       this.textInput.focus();
     });
   };
 }
 
 const ConnectedThreadSettingsName: React.ComponentType<BaseProps> =
   React.memo<BaseProps>(function ConnectedThreadSettingsName(props: BaseProps) {
     const styles = useStyles(unboundStyles);
     const colors = useColors();
 
     const threadID = props.threadInfo.id;
     const loadingStatus = useSelector(
       createLoadingStatusSelector(
         changeThreadSettingsActionTypes,
         `${changeThreadSettingsActionTypes.started}:${threadID}:name`,
       ),
     );
 
     const dispatchActionPromise = useDispatchActionPromise();
-    const callChangeThreadSettings = useChangeThreadSettings(props.threadInfo);
+    const callChangeThreadSettings = useChangeThreadSettings();
 
     return (
       <ThreadSettingsName
         {...props}
         styles={styles}
         colors={colors}
         loadingStatus={loadingStatus}
         dispatchActionPromise={dispatchActionPromise}
         changeThreadSettings={callChangeThreadSettings}
       />
     );
   });
 
 export default ConnectedThreadSettingsName;
diff --git a/web/modals/threads/members/add-members-modal.react.js b/web/modals/threads/members/add-members-modal.react.js
index 3998aafcd..35b03c44d 100644
--- a/web/modals/threads/members/add-members-modal.react.js
+++ b/web/modals/threads/members/add-members-modal.react.js
@@ -1,137 +1,138 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
 } from 'lib/actions/thread-actions.js';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors.js';
 import { useAddDMThreadMembers } from 'lib/shared/dm-ops/dm-op-utils.js';
 import { threadTypeIsThick } from 'lib/types/thread-types-enum.js';
 import { useDispatchActionPromise } from 'lib/utils/redux-promise-utils.js';
 import { useSelector } from 'lib/utils/redux-utils.js';
 
 import css from './members-modal.css';
 import Button from '../../../components/button.react.js';
 import {
   AddUsersListProvider,
   useAddUsersListContext,
 } from '../../../settings/relationship/add-users-list-provider.react.js';
 import AddUsersList from '../../../settings/relationship/add-users-list.react.js';
 import { useAddMembersListUserInfos } from '../../../settings/relationship/add-users-utils.js';
 import SearchModal from '../../search-modal.react.js';
 
 type ContentProps = {
   +searchText: string,
   +threadID: string,
 };
 
 function AddMembersList(props: ContentProps): React.Node {
   const { searchText, threadID } = props;
 
   const { userInfos, sortedUsersWithENSNames } = useAddMembersListUserInfos({
     threadID,
     searchText,
   });
 
   const addMembersList = React.useMemo(
     () => (
       <div className={css.addMembersListContainer}>
         <AddUsersList
           searchModeActive={searchText.length > 0}
           userInfos={userInfos}
           sortedUsersWithENSNames={sortedUsersWithENSNames}
         />
       </div>
     ),
     [searchText.length, sortedUsersWithENSNames, userInfos],
   );
 
   return addMembersList;
 }
 
 type Props = {
   +threadID: string,
   +onClose: () => void,
 };
 
 function AddMembersModalContent(props: Props): React.Node {
   const { threadID, onClose } = props;
 
   const { pendingUsersToAdd } = useAddUsersListContext();
 
   const dispatchActionPromise = useDispatchActionPromise();
   const callChangeThreadSettings = useChangeThreadSettings();
   const addDMThreadMembers = useAddDMThreadMembers();
   const threadInfo = useSelector(state => threadInfoSelector(state)[threadID]);
 
   const addUsers = React.useCallback(() => {
     const newMemberIDs = Array.from(pendingUsersToAdd.keys());
 
     if (threadTypeIsThick(threadInfo.type)) {
       void addDMThreadMembers(newMemberIDs, threadInfo);
     } else {
       void dispatchActionPromise(
         changeThreadSettingsActionTypes,
         callChangeThreadSettings({
+          thick: false,
           threadID,
           changes: { newMemberIDs },
         }),
       );
     }
     onClose();
   }, [
     addDMThreadMembers,
     callChangeThreadSettings,
     dispatchActionPromise,
     onClose,
     pendingUsersToAdd,
     threadID,
     threadInfo,
   ]);
 
   const primaryButton = React.useMemo(
     () => (
       <Button
         disabled={!pendingUsersToAdd.size}
         variant="filled"
         onClick={addUsers}
       >
         Add selected members
       </Button>
     ),
     [addUsers, pendingUsersToAdd.size],
   );
 
   const addMembersList = React.useCallback(
     (searchText: string) => (
       <AddMembersList searchText={searchText} threadID={threadID} />
     ),
     [threadID],
   );
 
   return (
     <SearchModal
       name="Add members"
       searchPlaceholder="Search members"
       onClose={onClose}
       size="large"
       primaryButton={primaryButton}
     >
       {addMembersList}
     </SearchModal>
   );
 }
 
 function AddMembersModal(props: Props): React.Node {
   const { threadID, onClose } = props;
 
   return (
     <AddUsersListProvider>
       <AddMembersModalContent threadID={threadID} onClose={onClose} />
     </AddUsersListProvider>
   );
 }
 
 export { AddMembersModal, AddMembersList };
diff --git a/web/modals/threads/settings/thread-settings-utils.js b/web/modals/threads/settings/thread-settings-utils.js
index 3b3c582e3..1d8932697 100644
--- a/web/modals/threads/settings/thread-settings-utils.js
+++ b/web/modals/threads/settings/thread-settings-utils.js
@@ -1,211 +1,223 @@
 // @flow
 
 import * as React from 'react';
 
 import {
   changeThreadSettingsActionTypes,
   useChangeThreadSettings,
   deleteThreadActionTypes,
   useDeleteThread,
 } from 'lib/actions/thread-actions.js';
 import { useModalContext } from 'lib/components/modal-provider.react.js';
 import { containedThreadInfos } from 'lib/selectors/thread-selectors.js';
 import { type SetState } from 'lib/types/hook-types.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
-import { type ThreadChanges } from 'lib/types/thread-types.js';
+import { threadTypeIsThick } from 'lib/types/thread-types-enum.js';
+import type { ThreadChanges } from 'lib/types/thread-types.js';
 import { useDispatchActionPromise } from 'lib/utils/redux-promise-utils.js';
 
 import ThreadDeleteConfirmationModal from './thread-settings-delete-confirmation-modal.react.js';
 import { useSelector } from '../../../redux/redux-utils.js';
 
 type UseOnSaveGeneralThreadSettingsParams = {
   +threadInfo: ThreadInfo,
   +queuedChanges: ThreadChanges,
   +setQueuedChanges: SetState<ThreadChanges>,
   +setErrorMessage: SetState<?string>,
 };
 
 function useOnSaveGeneralThreadSettings(
   params: UseOnSaveGeneralThreadSettingsParams,
 ): (event: SyntheticEvent<HTMLElement>) => mixed {
   const { threadInfo, queuedChanges, setQueuedChanges, setErrorMessage } =
     params;
 
   const dispatchActionPromise = useDispatchActionPromise();
-  const callChangeThreadSettings = useChangeThreadSettings(threadInfo);
+  const callChangeThreadSettings = useChangeThreadSettings();
 
   const changeThreadSettingsAction = React.useCallback(async () => {
     try {
       setErrorMessage('');
-      return await callChangeThreadSettings({
+      const changeThreadSettingsRequest = {
         threadID: threadInfo.id,
         changes: queuedChanges,
-      });
+      };
+
+      const changeThreadSettingsInput = threadTypeIsThick(threadInfo.type)
+        ? {
+            thick: true,
+            threadInfo,
+            ...changeThreadSettingsRequest,
+          }
+        : { thick: false, ...changeThreadSettingsRequest };
+
+      return await callChangeThreadSettings(changeThreadSettingsInput);
     } catch (e) {
       setErrorMessage('unknown_error');
       throw e;
     } finally {
       setQueuedChanges(Object.freeze({}));
     }
   }, [
     callChangeThreadSettings,
     queuedChanges,
     setErrorMessage,
     setQueuedChanges,
-    threadInfo.id,
+    threadInfo,
   ]);
 
   const onSubmit = React.useCallback(
     (event: SyntheticEvent<HTMLElement>) => {
       event.preventDefault();
       void dispatchActionPromise(
         changeThreadSettingsActionTypes,
         changeThreadSettingsAction(),
       );
     },
     [changeThreadSettingsAction, dispatchActionPromise],
   );
 
   return onSubmit;
 }
 
 type UseOnSavePrivacySettingsParams = {
   +threadInfo: ThreadInfo,
   +queuedChanges: ThreadChanges,
   +setQueuedChanges: SetState<ThreadChanges>,
   +setErrorMessage: SetState<?string>,
 };
 
 function useOnSavePrivacyThreadSettings(
   params: UseOnSavePrivacySettingsParams,
 ): (event: SyntheticEvent<HTMLElement>) => mixed {
   const { threadInfo, queuedChanges, setQueuedChanges, setErrorMessage } =
     params;
 
   const modalContext = useModalContext();
   const dispatchActionPromise = useDispatchActionPromise();
   const callChangeThreadSettings = useChangeThreadSettings();
 
   const changeThreadSettingsAction = React.useCallback(async () => {
     try {
       setErrorMessage('');
       const response = await callChangeThreadSettings({
+        thick: false,
         threadID: threadInfo.id,
         changes: queuedChanges,
       });
       modalContext.popModal();
       return response;
     } catch (e) {
       setErrorMessage('unknown_error');
       setQueuedChanges(Object.freeze({}));
       throw e;
     }
   }, [
     callChangeThreadSettings,
     modalContext,
     queuedChanges,
     setErrorMessage,
     setQueuedChanges,
     threadInfo.id,
   ]);
 
   const onSubmit = React.useCallback(
     (event: SyntheticEvent<HTMLElement>) => {
       event.preventDefault();
       void dispatchActionPromise(
         changeThreadSettingsActionTypes,
         changeThreadSettingsAction(),
       );
     },
     [changeThreadSettingsAction, dispatchActionPromise],
   );
 
   return onSubmit;
 }
 
 type UseOnDeleteParams = {
   +threadInfo: ThreadInfo,
   +setErrorMessage: SetState<?string>,
 };
 
 function useOnDeleteThread(
   params: UseOnDeleteParams,
 ): (event: SyntheticEvent<HTMLElement>) => mixed {
   const { threadInfo, setErrorMessage } = params;
 
   const modalContext = useModalContext();
   const dispatchActionPromise = useDispatchActionPromise();
   const callDeleteThread = useDeleteThread();
   const containedThreads = useSelector(
     state => containedThreadInfos(state)[threadInfo.id],
   );
 
   const shouldUseDeleteConfirmationModal = React.useMemo(
     () => containedThreads?.length > 0,
     [containedThreads?.length],
   );
 
   const popThreadDeleteConfirmationModal = React.useCallback(() => {
     if (shouldUseDeleteConfirmationModal) {
       modalContext.popModal();
     }
   }, [modalContext, shouldUseDeleteConfirmationModal]);
 
   const deleteThreadAction = React.useCallback(async () => {
     try {
       setErrorMessage('');
       const response = await callDeleteThread({ threadID: threadInfo.id });
       popThreadDeleteConfirmationModal();
       modalContext.popModal();
       return response;
     } catch (e) {
       popThreadDeleteConfirmationModal();
       setErrorMessage(
         e.message === 'invalid_credentials'
           ? 'permission not granted'
           : 'unknown error',
       );
       throw e;
     }
   }, [
     callDeleteThread,
     modalContext,
     popThreadDeleteConfirmationModal,
     setErrorMessage,
     threadInfo.id,
   ]);
 
   const dispatchDeleteThreadAction = React.useCallback(() => {
     void dispatchActionPromise(deleteThreadActionTypes, deleteThreadAction());
   }, [dispatchActionPromise, deleteThreadAction]);
 
   const onDelete = React.useCallback(
     (event: SyntheticEvent<HTMLElement>) => {
       event.preventDefault();
       if (shouldUseDeleteConfirmationModal) {
         modalContext.pushModal(
           <ThreadDeleteConfirmationModal
             threadInfo={threadInfo}
             onConfirmation={dispatchDeleteThreadAction}
           />,
         );
       } else {
         dispatchDeleteThreadAction();
       }
     },
     [
       dispatchDeleteThreadAction,
       modalContext,
       shouldUseDeleteConfirmationModal,
       threadInfo,
     ],
   );
 
   return onDelete;
 }
 
 export {
   useOnSaveGeneralThreadSettings,
   useOnSavePrivacyThreadSettings,
   useOnDeleteThread,
 };