diff --git a/addons/hr/models/res_partner.py b/addons/hr/models/res_partner.py
index 22d315aa68f..e51f0069dd7 100644
--- a/addons/hr/models/res_partner.py
+++ b/addons/hr/models/res_partner.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
 
-from odoo import api, models
+from odoo import models
 from odoo.exceptions import AccessError
 
 
@@ -9,19 +9,6 @@ class Partner(models.Model):
 
     _inherit = ['res.partner']
 
-    @api.model
-    def get_static_mention_suggestions(self):
-        """ Extend the mail's static mention suggestions by adding the employees. """
-        suggestions = super(Partner, self).get_static_mention_suggestions()
-
-        try:
-            employee_group = self.env.ref('base.group_user')
-            hr_suggestions = [{'id': user.partner_id.id, 'name': user.name, 'email': user.email} for user in employee_group.users]
-            suggestions.append(hr_suggestions)
-            return suggestions
-        except AccessError:
-            return suggestions
-
     def name_get(self):
         """ Override to allow an employee to see its private address in his profile.
             This avoids to relax access rules on `res.parter` and to add an `ir.rule`.
diff --git a/addons/mail/models/mail_channel.py b/addons/mail/models/mail_channel.py
index fbc56cde19b..d3f6100afe3 100644
--- a/addons/mail/models/mail_channel.py
+++ b/addons/mail/models/mail_channel.py
@@ -604,7 +604,14 @@ class Channel(models.Model):
 
         self.filtered(lambda channel: channel.is_chat).mapped('channel_last_seen_partner_ids').sudo().write({'is_pinned': True})
 
-        message = super(Channel, self.with_context(mail_create_nosubscribe=True)).message_post(message_type=message_type, moderation_status=moderation_status, **kwargs)
+        # mail_post_autofollow=False is necessary to prevent adding followers
+        # when using mentions in channels. Followers should not be added to
+        # channels, and especially not automatically (because channel membership
+        # should be managed with channel.partner instead).
+        # The current client code might be setting the key to True on sending
+        # message but it is only useful when targeting customers in chatter.
+        # This value should simply be set to False in channels no matter what.
+        message = super(Channel, self.with_context(mail_create_nosubscribe=True, mail_post_autofollow=False)).message_post(message_type=message_type, moderation_status=moderation_status, **kwargs)
 
         # Notifies the message author when his message is pending moderation if required on channel.
         # The fields "email_from" and "reply_to" are filled in automatically by method create in model mail.message.
@@ -1165,7 +1172,7 @@ class Channel(models.Model):
                             [('channel_partner_ids', 'in', [self.env.user.partner_id.id])]
                         ])
                     ])
-        return self.search_read(domain, ['id', 'name', 'public'], limit=limit)
+        return self.search_read(domain, ['id', 'name', 'public', 'channel_type'], limit=limit)
 
     @api.model
     def channel_fetch_listeners(self, uuid):
diff --git a/addons/mail/models/res_partner.py b/addons/mail/models/res_partner.py
index 2167c2d5354..0fbad5d9a5e 100644
--- a/addons/mail/models/res_partner.py
+++ b/addons/mail/models/res_partner.py
@@ -6,6 +6,7 @@ import logging
 from odoo import _, api, fields, models, tools
 from odoo.addons.bus.models.bus_presence import AWAY_TIMER
 from odoo.addons.bus.models.bus_presence import DISCONNECTION_TIMER
+from odoo.exceptions import AccessError
 from odoo.osv import expression
 
 _logger = logging.getLogger(__name__)
@@ -71,13 +72,20 @@ class Partner(models.Model):
 
     def mail_partner_format(self):
         self.ensure_one()
-        return {
-            "id": self.name_get()[0][0],
-            "display_name": self.name_get()[0][1],
+        internal_users = self.user_ids - self.user_ids.filtered('share')
+        main_user = internal_users[0] if len(internal_users) > 0 else self.user_ids[0] if len(self.user_ids) > 0 else self.env['res.users']
+        res = {
+            "id": self.id,
+            "display_name": self.display_name,
             "name": self.name,
+            "email": self.email,
             "active": self.active,
             "im_status": self.im_status,
+            "user_id": main_user.id,
         }
+        if main_user:
+            res["is_internal_user"] = not main_user.share
+        return res
 
     @api.model
     def get_needaction_count(self):
@@ -106,36 +114,39 @@ class Partner(models.Model):
 
     @api.model
     def get_static_mention_suggestions(self):
-        """ To be overwritten to return the id, name and email of partners used as static mention
-            suggestions loaded once at webclient initialization and stored client side. """
-        return []
+        """ Returns static mention suggestions of partners, loaded once at webclient initialization
+            and stored client side. All the internal users are returned.
+            The return format is a list of partner data (as per returned by `mail_partner_format()`).
+        """
+        partners = self.env['res.partner']
+        try:
+            partners = self.env.ref('base.group_user').users.partner_id
+        except AccessError:
+            pass
+        return [partner.mail_partner_format() for partner in partners]
 
     @api.model
-    def get_mention_suggestions(self, search, limit=8):
-        """ Return 'limit'-first partners' id, name and email such that the name or email matches a
-            'search' string. Prioritize users, and then extend the research to all partners. """
+    def get_mention_suggestions(self, search, limit=8, channel_id=None):
+        """ Return 'limit'-first partners' such that the name or email matches a 'search' string.
+            Prioritize partners that are also users, and then extend the research to all partners.
+            If channel_id is given, only members of this channel are returned.
+            The return format is a list of partner data (as per returned by `mail_partner_format()`).
+        """
         search_dom = expression.OR([[('name', 'ilike', search)], [('email', 'ilike', search)]])
         search_dom = expression.AND([[('active', '=', True)], search_dom])
-        fields = ['id', 'name', 'email']
+        if channel_id:
+            search_dom = expression.AND([[('channel_ids', 'in', channel_id)], search_dom])
 
-        # Search users
+        # Search partners that are also users
         domain = expression.AND([[('user_ids.id', '!=', False), ('user_ids.active', '=', True)], search_dom])
-        users = self.search_read(domain, fields, limit=limit)
+        partners = self.search(domain, limit=limit)
 
-        # Search partners if less than 'limit' users found
-        partners = []
-        if len(users) < limit:
-            partners = self.search_read(search_dom, fields, limit=limit)
-            # Remove duplicates
-            partners = [p for p in partners if not len([u for u in users if u['id'] == p['id']])] 
+        # Search partners that are not users if less than 'limit' partner that are users found
+        remaining_limit = limit - len(partners)
+        if remaining_limit > 0:
+            partners |= self.search(expression.AND([[('id', 'not in', partners.ids)], search_dom]), limit=remaining_limit)
 
-        # add OdooBot even if its partner is archived
-        if len(partners) + len(users) < limit and "odoobot".startswith(search.lower()):
-            odoobot = self.env.ref("base.partner_root")
-            if not any(elem['id'] == odoobot.id for elem in partners):
-                partners.append(odoobot.read(fields)[0])
-
-        return [users, partners]
+        return [partner.mail_partner_format() for partner in partners]
 
     @api.model
     def im_search(self, name, limit=20):
diff --git a/addons/mail/static/src/components/composer/composer_tests.js b/addons/mail/static/src/components/composer/composer_tests.js
index ff1c9333acf..d30d2ea3f09 100644
--- a/addons/mail/static/src/components/composer/composer_tests.js
+++ b/addons/mail/static/src/components/composer/composer_tests.js
@@ -402,8 +402,6 @@ QUnit.test('use a canned response', async function (assert) {
     await afterNextRender(() => {
         document.querySelector(`.o_ComposerTextInput_textarea`).focus();
         document.execCommand('insertText', false, ":");
-    });
-    await afterNextRender(() => {
         document.querySelector(`.o_ComposerTextInput_textarea`)
             .dispatchEvent(new window.KeyboardEvent('keydown'));
         document.querySelector(`.o_ComposerTextInput_textarea`)
@@ -462,10 +460,8 @@ QUnit.test('use a canned response some text', async function (assert) {
         "bluhbluh ",
         "text content of composer should have content"
     );
-    await afterNextRender(() =>
-        document.execCommand('insertText', false, ":")
-    );
     await afterNextRender(() => {
+        document.execCommand('insertText', false, ":");
         document.querySelector(`.o_ComposerTextInput_textarea`)
             .dispatchEvent(new window.KeyboardEvent('keydown'));
         document.querySelector(`.o_ComposerTextInput_textarea`)
@@ -518,8 +514,6 @@ QUnit.test('add an emoji after a canned response', async function (assert) {
     await afterNextRender(() => {
         document.querySelector(`.o_ComposerTextInput_textarea`).focus();
         document.execCommand('insertText', false, ":");
-    });
-    await afterNextRender(() => {
         document.querySelector(`.o_ComposerTextInput_textarea`)
             .dispatchEvent(new window.KeyboardEvent('keydown'));
         document.querySelector(`.o_ComposerTextInput_textarea`)
@@ -619,8 +613,6 @@ QUnit.test('mention a channel', async function (assert) {
     await afterNextRender(() => {
         document.querySelector(`.o_ComposerTextInput_textarea`).focus();
         document.execCommand('insertText', false, "#");
-    });
-    await afterNextRender(() => {
         document.querySelector(`.o_ComposerTextInput_textarea`)
             .dispatchEvent(new window.KeyboardEvent('keydown'));
         document.querySelector(`.o_ComposerTextInput_textarea`)
@@ -675,10 +667,8 @@ QUnit.test('mention a channel after some text', async function (assert) {
         "bluhbluh ",
         "text content of composer should have content"
     );
-    await afterNextRender(() =>
-        document.execCommand('insertText', false, "#")
-    );
     await afterNextRender(() => {
+        document.execCommand('insertText', false, "#");
         document.querySelector(`.o_ComposerTextInput_textarea`)
             .dispatchEvent(new window.KeyboardEvent('keydown'));
         document.querySelector(`.o_ComposerTextInput_textarea`)
@@ -727,8 +717,6 @@ QUnit.test('add an emoji after a channel mention', async function (assert) {
     await afterNextRender(() => {
         document.querySelector(`.o_ComposerTextInput_textarea`).focus();
         document.execCommand('insertText', false, "#");
-    });
-    await afterNextRender(() => {
         document.querySelector(`.o_ComposerTextInput_textarea`)
             .dispatchEvent(new window.KeyboardEvent('keydown'));
         document.querySelector(`.o_ComposerTextInput_textarea`)
@@ -833,8 +821,6 @@ QUnit.test('use a command for a specific channel type', async function (assert)
     await afterNextRender(() => {
         document.querySelector(`.o_ComposerTextInput_textarea`).focus();
         document.execCommand('insertText', false, "/");
-    });
-    await afterNextRender(() => {
         document.querySelector(`.o_ComposerTextInput_textarea`)
             .dispatchEvent(new window.KeyboardEvent('keydown'));
         document.querySelector(`.o_ComposerTextInput_textarea`)
@@ -922,10 +908,8 @@ QUnit.test('use a command after some text', async function (assert) {
         "bluhbluh ",
         "text content of composer should have content"
     );
-    await afterNextRender(() =>
-        document.execCommand('insertText', false, "/")
-    );
     await afterNextRender(() => {
+        document.execCommand('insertText', false, "/");
         document.querySelector(`.o_ComposerTextInput_textarea`)
             .dispatchEvent(new window.KeyboardEvent('keydown'));
         document.querySelector(`.o_ComposerTextInput_textarea`)
@@ -977,8 +961,6 @@ QUnit.test('add an emoji after a command', async function (assert) {
     await afterNextRender(() => {
         document.querySelector(`.o_ComposerTextInput_textarea`).focus();
         document.execCommand('insertText', false, "/");
-    });
-    await afterNextRender(() => {
         document.querySelector(`.o_ComposerTextInput_textarea`)
             .dispatchEvent(new window.KeyboardEvent('keydown'));
         document.querySelector(`.o_ComposerTextInput_textarea`)
@@ -2220,61 +2202,6 @@ QUnit.test('send message only once when enter is pressed twice quickly', async f
     );
 });
 
-QUnit.test("mentioned partners should not be notified if they are not member of current channel", async function (assert) {
-    assert.expect(4);
-
-    this.data['res.partner'].records.push({
-        email: "testpartner@example.com",
-        name: "TestPartner",
-    });
-    this.data['mail.channel'].records.push({
-        id: 10,
-        members: [this.data.currentPartnerId],
-    });
-    await this.start({
-        async mockRPC(route, args) {
-            if (args.model === 'mail.channel' && args.method === 'message_post') {
-                assert.step('message_post');
-                assert.strictEqual(
-                    args.kwargs.partner_ids.length,
-                    0,
-                    "message_post should not contain mentioned partners that are not members of channel"
-                );
-            }
-            return this._super(...arguments);
-        },
-    });
-    const thread = this.env.models['mail.thread'].findFromIdentifyingData({
-        id: 10,
-        model: 'mail.channel',
-    });
-    await this.createComposerComponent(thread.composer);
-    await afterNextRender(() => {
-        document.querySelector(`.o_ComposerTextInput_textarea`).focus();
-        document.execCommand('insertText', false, "@");
-        document.querySelector(`.o_ComposerTextInput_textarea`)
-            .dispatchEvent(new window.KeyboardEvent('keydown'));
-        document.querySelector(`.o_ComposerTextInput_textarea`)
-            .dispatchEvent(new window.KeyboardEvent('keyup'));
-    });
-    await afterNextRender(() => {
-        document.querySelector(`.o_ComposerTextInput_textarea`).focus();
-        document.execCommand('insertText', false, "Test");
-        document.querySelector(`.o_ComposerTextInput_textarea`)
-            .dispatchEvent(new window.KeyboardEvent('keydown'));
-        document.querySelector(`.o_ComposerTextInput_textarea`)
-            .dispatchEvent(new window.KeyboardEvent('keyup'));
-    });
-    await afterNextRender(() => document.querySelector('.o_ComposerSuggestion').click());
-    assert.strictEqual(
-        document.querySelector(`.o_ComposerTextInput_textarea`).value.replace(/\s/, " "),
-        "@TestPartner ",
-        "text content of composer should have mentioned partner + additional whitespace afterwards"
-    );
-    await afterNextRender(() => document.querySelector('.o_Composer_buttonSend').click());
-    assert.verifySteps(['message_post'], "the message should be posted");
-});
-
 QUnit.test('[technical] does not crash when an attachment is removed before its upload starts', async function (assert) {
     // Uploading multiple files uploads attachments one at a time, this test
     // ensures that there is no crash when an attachment is destroyed before its
diff --git a/addons/mail/static/src/components/composer_suggestion/composer_suggestion.js b/addons/mail/static/src/components/composer_suggestion/composer_suggestion.js
index 4ae48db623b..da54ab54311 100644
--- a/addons/mail/static/src/components/composer_suggestion/composer_suggestion.js
+++ b/addons/mail/static/src/components/composer_suggestion/composer_suggestion.js
@@ -116,9 +116,7 @@ class ComposerSuggestion extends Component {
      */
     _onClick(ev) {
         ev.preventDefault();
-        this.composer.update({
-            [this.composer.activeSuggestedRecordName]: [['link', this.record]],
-        });
+        this.composer.update({ activeSuggestedRecord: [['link', this.record]] });
         this.composer.insertSuggestion();
         this.composer.closeSuggestions();
         this.trigger('o-composer-suggestion-clicked');
diff --git a/addons/mail/static/src/components/composer_suggestion_list/composer_suggestion_list.js b/addons/mail/static/src/components/composer_suggestion_list/composer_suggestion_list.js
index ea2153dbf6f..23f08399594 100644
--- a/addons/mail/static/src/components/composer_suggestion_list/composer_suggestion_list.js
+++ b/addons/mail/static/src/components/composer_suggestion_list/composer_suggestion_list.js
@@ -22,23 +22,23 @@ class ComposerSuggestionList extends Component {
             const activeSuggestedRecord = composer
                 ? composer.activeSuggestedRecord
                 : undefined;
-            const extraSuggestedRecordsList = composer
-                ? composer.extraSuggestedRecordsList
+            const extraSuggestedRecords = composer
+                ? composer.extraSuggestedRecords
                 : [];
-            const mainSuggestedRecordsList = composer
-                ? composer.mainSuggestedRecordsList
+            const mainSuggestedRecords = composer
+                ? composer.mainSuggestedRecords
                 : [];
             return {
                 activeSuggestedRecord,
                 composer,
                 composerSuggestionModelName: composer && composer.suggestionModelName,
-                extraSuggestedRecordsList: extraSuggestedRecordsList,
-                mainSuggestedRecordsList: mainSuggestedRecordsList,
+                extraSuggestedRecords,
+                mainSuggestedRecords,
             };
         }, {
             compareDepth: {
-                extraSuggestedRecordsList: 1,
-                mainSuggestedRecordsList: 1,
+                extraSuggestedRecords: 1,
+                mainSuggestedRecords: 1,
             },
         });
     }
diff --git a/addons/mail/static/src/components/composer_suggestion_list/composer_suggestion_list.xml b/addons/mail/static/src/components/composer_suggestion_list/composer_suggestion_list.xml
index 8bcd87c2d07..9747109a994 100644
--- a/addons/mail/static/src/components/composer_suggestion_list/composer_suggestion_list.xml
+++ b/addons/mail/static/src/components/composer_suggestion_list/composer_suggestion_list.xml
@@ -5,7 +5,7 @@
         <div class="o_ComposerSuggestionList" t-att-class="{ 'o-lowPosition': props.isBelow }">
             <div class="o_ComposerSuggestionList_drop" t-att-class="{ 'dropdown': props.isBelow, 'dropup': !props.isBelow }">
                 <div class="o_ComposerSuggestionList_list dropdown-menu show">
-                    <t t-foreach="composer.mainSuggestedRecordsList" t-as="record" t-key="record.localId">
+                    <t t-foreach="composer.mainSuggestedRecords" t-as="record" t-key="record.localId">
                         <ComposerSuggestion
                             composerLocalId="props.composerLocalId"
                             isActive="record === composer.activeSuggestedRecord"
@@ -13,10 +13,10 @@
                             recordLocalId="record.localId"
                         />
                     </t>
-                    <t t-if="composer.mainSuggestedRecordsList.length > 0 and composer.extraSuggestedRecordsList.length > 0">
+                    <t t-if="composer.mainSuggestedRecords.length > 0 and composer.extraSuggestedRecords.length > 0">
                         <div role="separator" class="dropdown-divider"/>
                     </t>
-                    <t t-foreach="composer.extraSuggestedRecordsList" t-as="record" t-key="record.localId">
+                    <t t-foreach="composer.extraSuggestedRecords" t-as="record" t-key="record.localId">
                         <ComposerSuggestion
                             composerLocalId="props.composerLocalId"
                             isActive="record === composer.activeSuggestedRecord"
diff --git a/addons/mail/static/src/components/composer_text_input/composer_text_input.js b/addons/mail/static/src/components/composer_text_input/composer_text_input.js
index 48bbd07a3a3..3dc38e0c920 100644
--- a/addons/mail/static/src/components/composer_text_input/composer_text_input.js
+++ b/addons/mail/static/src/components/composer_text_input/composer_text_input.js
@@ -203,6 +203,14 @@ class ComposerTextInput extends Component {
     // Handlers
     //--------------------------------------------------------------------------
 
+    /**
+     * @private
+     */
+    _onClickTextarea() {
+        // clicking might change the cursor position
+        this.saveStateInStore();
+    }
+
     /**
      * @private
      */
@@ -383,7 +391,6 @@ class ComposerTextInput extends Component {
             // Otherwise, check if a mention is typed
             default:
                 this.saveStateInStore();
-                this.composer.detectSuggestionDelimiter();
         }
     }
 
diff --git a/addons/mail/static/src/components/composer_text_input/composer_text_input.xml b/addons/mail/static/src/components/composer_text_input/composer_text_input.xml
index 5b120fabd90..a14fdee8712 100644
--- a/addons/mail/static/src/components/composer_text_input/composer_text_input.xml
+++ b/addons/mail/static/src/components/composer_text_input/composer_text_input.xml
@@ -10,7 +10,7 @@
                         isBelow="props.hasMentionSuggestionsBelowPosition"
                     />
                 </t>
-                <textarea class="o_ComposerTextInput_textarea o_ComposerTextInput_textareaStyle" t-att-class="{ 'o-composer-is-compact': props.isCompact }" t-esc="composer.textInputContent" t-att-placeholder="textareaPlaceholder" t-on-focusin="_onFocusinTextarea" t-on-focusout="_onFocusoutTextarea" t-on-keydown="_onKeydownTextarea" t-on-keyup="_onKeyupTextarea" t-on-input="_onInputTextarea" t-ref="textarea"/>
+                <textarea class="o_ComposerTextInput_textarea o_ComposerTextInput_textareaStyle" t-att-class="{ 'o-composer-is-compact': props.isCompact }" t-esc="composer.textInputContent" t-att-placeholder="textareaPlaceholder" t-on-click="_onClickTextarea" t-on-focusin="_onFocusinTextarea" t-on-focusout="_onFocusoutTextarea" t-on-keydown="_onKeydownTextarea" t-on-keyup="_onKeyupTextarea" t-on-input="_onInputTextarea" t-ref="textarea"/>
                 <!--
                      This is an invisible textarea used to compute the composer
                      height based on the text content. We need it to downsize
diff --git a/addons/mail/static/src/components/discuss_sidebar_item/discuss_sidebar_item.xml b/addons/mail/static/src/components/discuss_sidebar_item/discuss_sidebar_item.xml
index 9b52651f0c6..74aace2181b 100644
--- a/addons/mail/static/src/components/discuss_sidebar_item/discuss_sidebar_item.xml
+++ b/addons/mail/static/src/components/discuss_sidebar_item/discuss_sidebar_item.xml
@@ -16,7 +16,7 @@
                     <div class="o_DiscussSidebarItem_item o_DiscussSidebarItem_name o-editable">
                         <EditableText
                             class="o_DiscussSidebarItem_nameInput"
-                            placeholder="thread.correspondent.name"
+                            placeholder="thread.correspondent ? thread.correspondent.name : thread.name"
                             value="thread.displayName"
                             t-on-o-cancel="_onCancelRenaming"
                             t-on-o-clicked="_onClickedEditableText"
diff --git a/addons/mail/static/src/components/thread_view/thread_view_tests.js b/addons/mail/static/src/components/thread_view/thread_view_tests.js
index a3e1f15eb1a..1ddeb0d754a 100644
--- a/addons/mail/static/src/components/thread_view/thread_view_tests.js
+++ b/addons/mail/static/src/components/thread_view/thread_view_tests.js
@@ -1481,6 +1481,7 @@ QUnit.test('mention 2 different channels that have the same name', async functio
         {
             id: 11,
             name: "my channel",
+            public: 'public', // mentioning another channel is possible only from a public channel
         },
         {
             id: 12,
diff --git a/addons/mail/static/src/models/canned_response/canned_response.js b/addons/mail/static/src/models/canned_response/canned_response.js
index 19375fd7ccd..41e917d2ac4 100644
--- a/addons/mail/static/src/models/canned_response/canned_response.js
+++ b/addons/mail/static/src/models/canned_response/canned_response.js
@@ -3,10 +3,86 @@ odoo.define('mail/static/src/models/canned_response/canned_response.js', functio
 
 const { registerNewModel } = require('mail/static/src/model/model_core.js');
 const { attr } = require('mail/static/src/model/model_field.js');
+const { cleanSearchTerm } = require('mail/static/src/utils/utils.js');
 
 function factory(dependencies) {
 
-    class CannedResponse extends dependencies['mail.model'] {}
+    class CannedResponse extends dependencies['mail.model'] {
+
+        /**
+         * Fetches canned responses matching the given search term to extend the
+         * JS knowledge and to update the suggestion list accordingly.
+         *
+         * In practice all canned responses are already fetched at init so this
+         * method does nothing.
+         *
+         * @static
+         * @param {string} searchTerm
+         * @param {Object} [options={}]
+         * @param {mail.thread} [options.thread] prioritize and/or restrict
+         *  result in the context of given thread
+         */
+        static fetchSuggestions(searchTerm, { thread } = {}) {}
+
+        /**
+         * Returns a sort function to determine the order of display of canned
+         * responses in the suggestion list.
+         *
+         * @static
+         * @param {string} searchTerm
+         * @param {Object} [options={}]
+         * @param {mail.thread} [options.thread] prioritize result in the
+         *  context of given thread
+         * @returns {function}
+         */
+        static getSuggestionSortFunction(searchTerm, { thread } = {}) {
+            const cleanedSearchTerm = cleanSearchTerm(searchTerm);
+            return (a, b) => {
+                const cleanedAName = cleanSearchTerm(a.source || '');
+                const cleanedBName = cleanSearchTerm(b.source || '');
+                if (cleanedAName.startsWith(cleanedSearchTerm) && !cleanedBName.startsWith(cleanedSearchTerm)) {
+                    return -1;
+                }
+                if (!cleanedAName.startsWith(cleanedSearchTerm) && cleanedBName.startsWith(cleanedSearchTerm)) {
+                    return 1;
+                }
+                if (cleanedAName < cleanedBName) {
+                    return -1;
+                }
+                if (cleanedAName > cleanedBName) {
+                    return 1;
+                }
+                return a.id - b.id;
+            };
+        }
+
+        /*
+         * Returns canned responses that match the given search term.
+         *
+         * @static
+         * @param {string} searchTerm
+         * @param {Object} [options={}]
+         * @param {mail.thread} [options.thread] prioritize and/or restrict
+         *  result in the context of given thread
+         * @returns {[mail.canned_response[], mail.canned_response[]]}
+         */
+        static searchSuggestions(searchTerm, { thread } = {}) {
+            const cleanedSearchTerm = cleanSearchTerm(searchTerm);
+            return [this.env.messaging.cannedResponses.filter(cannedResponse =>
+                cleanSearchTerm(cannedResponse.source).includes(cleanedSearchTerm)
+            )];
+        }
+
+        /**
+         * Returns the text that identifies this canned response in a mention.
+         *
+         * @returns {string}
+         */
+        getMentionText() {
+            return this.substitution;
+        }
+
+    }
 
     CannedResponse.fields = {
         id: attr(),
diff --git a/addons/mail/static/src/models/channel_command/channel_command.js b/addons/mail/static/src/models/channel_command/channel_command.js
index 12054c1a35b..728acdb9eab 100644
--- a/addons/mail/static/src/models/channel_command/channel_command.js
+++ b/addons/mail/static/src/models/channel_command/channel_command.js
@@ -3,10 +3,104 @@ odoo.define('mail/static/src/models/channel_command/channel_command.js', functio
 
 const { registerNewModel } = require('mail/static/src/model/model_core.js');
 const { attr } = require('mail/static/src/model/model_field.js');
+const { cleanSearchTerm } = require('mail/static/src/utils/utils.js');
 
 function factory(dependencies) {
 
-    class ChannelCommand extends dependencies['mail.model'] {}
+    class ChannelCommand extends dependencies['mail.model'] {
+
+        /**
+         * Fetches channel commands matching the given search term to extend the
+         * JS knowledge and to update the suggestion list accordingly.
+         *
+         * In practice all channel commands are already fetched at init so this
+         * method does nothing.
+         *
+         * @static
+         * @param {string} searchTerm
+         * @param {Object} [options={}]
+         * @param {mail.thread} [options.thread] prioritize and/or restrict
+         *  result in the context of given thread
+         */
+        static fetchSuggestions(searchTerm, { thread } = {}) {}
+
+        /**
+         * Returns a sort function to determine the order of display of channel
+         * commands in the suggestion list.
+         *
+         * @static
+         * @param {string} searchTerm
+         * @param {Object} [options={}]
+         * @param {mail.thread} [options.thread] prioritize result in the
+         *  context of given thread
+         * @returns {function}
+         */
+        static getSuggestionSortFunction(searchTerm, { thread } = {}) {
+            const cleanedSearchTerm = cleanSearchTerm(searchTerm);
+            return (a, b) => {
+                const isATypeSpecific = a.channel_types;
+                const isBTypeSpecific = b.channel_types;
+                if (isATypeSpecific && !isBTypeSpecific) {
+                    return -1;
+                }
+                if (!isATypeSpecific && isBTypeSpecific) {
+                    return 1;
+                }
+                const cleanedAName = cleanSearchTerm(a.name || '');
+                const cleanedBName = cleanSearchTerm(b.name || '');
+                if (cleanedAName.startsWith(cleanedSearchTerm) && !cleanedBName.startsWith(cleanedSearchTerm)) {
+                    return -1;
+                }
+                if (!cleanedAName.startsWith(cleanedSearchTerm) && cleanedBName.startsWith(cleanedSearchTerm)) {
+                    return 1;
+                }
+                if (cleanedAName < cleanedBName) {
+                    return -1;
+                }
+                if (cleanedAName > cleanedBName) {
+                    return 1;
+                }
+                return a.id - b.id;
+            };
+        }
+
+        /**
+         * Returns channel commands that match the given search term.
+         *
+         * @static
+         * @param {string} searchTerm
+         * @param {Object} [options={}]
+         * @param {mail.thread} [options.thread] prioritize and/or restrict
+         *  result in the context of given thread
+         * @returns {[mail.channel_command[], mail.channel_command[]]}
+         */
+        static searchSuggestions(searchTerm, { thread } = {}) {
+            if (thread.model !== 'mail.channel') {
+                // channel commands are channel specific
+                return [[]];
+            }
+            const cleanedSearchTerm = cleanSearchTerm(searchTerm);
+            return [this.env.messaging.commands.filter(command => {
+                if (!cleanSearchTerm(command.name).includes(cleanedSearchTerm)) {
+                    return false;
+                }
+                if (command.channel_types) {
+                    return command.channel_types.includes(thread.channel_type);
+                }
+                return true;
+            })];
+        }
+
+        /**
+         * Returns the text that identifies this channel command in a mention.
+         *
+         * @returns {string}
+         */
+        getMentionText() {
+            return this.name;
+        }
+
+    }
 
     ChannelCommand.fields = {
         /**
diff --git a/addons/mail/static/src/models/composer/composer.js b/addons/mail/static/src/models/composer/composer.js
index 301ec2c9967..93fc61061f3 100644
--- a/addons/mail/static/src/models/composer/composer.js
+++ b/addons/mail/static/src/models/composer/composer.js
@@ -4,6 +4,7 @@ odoo.define('mail/static/src/models/composer/composer.js', function (require) {
 const emojis = require('mail.emojis');
 const { registerNewModel } = require('mail/static/src/model/model_core.js');
 const { attr, many2many, many2one, one2one } = require('mail/static/src/model/model_field.js');
+const { clear } = require('mail/static/src/model/model_field_command.js');
 const mailUtils = require('mail.utils');
 
 const {
@@ -48,79 +49,11 @@ function factory(dependencies) {
         // Public
         //----------------------------------------------------------------------
 
+        /**
+         * Closes the suggestion list.
+         */
         closeSuggestions() {
-            if (this.activeSuggestedRecordName) {
-                this.update({
-                    [this.activeSuggestedRecordName]: [['unlink']],
-                });
-            }
-            if (this.extraSuggestedRecordsListName) {
-                this.update({
-                    [this.extraSuggestedRecordsListName]: [['unlink-all']],
-                });
-            }
-            if (this.mainSuggestedRecordsListName) {
-                this.update({
-                    [this.mainSuggestedRecordsListName]: [['unlink-all']],
-                });
-            }
-            this.update({
-                activeSuggestedRecordName: "",
-                extraSuggestedRecordsListName: "",
-                mainSuggestedRecordsListName: "",
-                suggestionDelimiter: "",
-            });
-        }
-
-        detectSuggestionDelimiter() {
-            if (this.textInputCursorStart !== this.textInputCursorEnd) {
-                return;
-            }
-            const lastInputChar = this.textInputContent.substring(this.textInputCursorStart - 1, this.textInputCursorStart);
-            const suggestionDelimiters = ['@', ':', '#', '/'];
-            if (suggestionDelimiters.includes(lastInputChar) && !this.hasSuggestions) {
-                this.update({ suggestionDelimiter: lastInputChar });
-            }
-            const mentionKeyword = this._validateMentionKeyword(false);
-            if (mentionKeyword !== false) {
-                switch (this.suggestionDelimiter) {
-                    case '@':
-                        this.update({
-                            activeSuggestedRecordName: "activeSuggestedPartner",
-                            extraSuggestedRecordsListName: "extraSuggestedPartners",
-                            mainSuggestedRecordsListName: "mainSuggestedPartners",
-                            suggestionModelName: "mail.partner",
-                        });
-                        this._executeOrQueueFunction(() => this._updateSuggestedPartners(mentionKeyword));
-                        break;
-                    case ':':
-                        this.update({
-                            activeSuggestedRecordName: "activeSuggestedCannedResponse",
-                            mainSuggestedRecordsListName: "suggestedCannedResponses",
-                            suggestionModelName: "mail.canned_response",
-                        });
-                        this._executeOrQueueFunction(() => this._updateSuggestedCannedResponses(mentionKeyword));
-                        break;
-                    case '/':
-                        this.update({
-                            activeSuggestedRecordName: "activeSuggestedChannelCommand",
-                            mainSuggestedRecordsListName: "suggestedChannelCommands",
-                            suggestionModelName: "mail.channel_command",
-                        });
-                        this._executeOrQueueFunction(() => this._updateSuggestedChannelCommands(mentionKeyword));
-                        break;
-                    case '#':
-                        this.update({
-                            activeSuggestedRecordName: "activeSuggestedChannel",
-                            mainSuggestedRecordsListName: "suggestedChannels",
-                            suggestionModelName: "mail.thread",
-                        });
-                        this._executeOrQueueFunction(() => this._updateSuggestedChannels(mentionKeyword));
-                        break;
-                }
-            } else {
-                this.closeSuggestions();
-            }
+            this.update({ suggestionDelimiterPosition: clear() });
         }
 
         /**
@@ -159,11 +92,19 @@ function factory(dependencies) {
                 this.textInputCursorEnd,
                 this.textInputContent.length
             );
+            let suggestionDelimiterPosition = this.suggestionDelimiterPosition;
+            if (
+                suggestionDelimiterPosition !== undefined &&
+                suggestionDelimiterPosition >= this.textInputCursorStart
+            ) {
+                suggestionDelimiterPosition = suggestionDelimiterPosition + content.length;
+            }
             this.update({
                 isLastStateChangeProgrammatic: true,
+                suggestionDelimiterPosition,
                 textInputContent: partA + content + partB,
-                textInputCursorStart: this.textInputCursorStart + content.length,
                 textInputCursorEnd: this.textInputCursorStart + content.length,
+                textInputCursorStart: this.textInputCursorStart + content.length,
             });
         }
 
@@ -171,7 +112,7 @@ function factory(dependencies) {
             const cursorPosition = this.textInputCursorStart;
             let textLeft = this.textInputContent.substring(
                 0,
-                this.textInputContent.substring(0, cursorPosition).lastIndexOf(this.suggestionDelimiter) + 1
+                this.suggestionDelimiterPosition + 1
             );
             let textRight = this.textInputContent.substring(
                 cursorPosition,
@@ -180,40 +121,32 @@ function factory(dependencies) {
             if (this.suggestionDelimiter === ':') {
                 textLeft = this.textInputContent.substring(
                     0,
-                    this.textInputContent.substring(0, cursorPosition).lastIndexOf(this.suggestionDelimiter)
+                    this.suggestionDelimiterPosition
                 );
                 textRight = this.textInputContent.substring(
                     cursorPosition,
                     this.textInputContent.length
                 );
             }
-            let recordReplacement = "";
-            switch (this.activeSuggestedRecordName) {
-                case 'activeSuggestedCannedResponse':
-                    recordReplacement = this[this.activeSuggestedRecordName].substitution;
-                    break;
-                case 'activeSuggestedChannel':
-                    recordReplacement = this[this.activeSuggestedRecordName].name;
-                    this.update({
-                        mentionedChannels: [['link', this[this.activeSuggestedRecordName]]],
-                    });
-                    break;
-                case 'activeSuggestedChannelCommand':
-                    recordReplacement = this[this.activeSuggestedRecordName].name;
-                    break;
-                case 'activeSuggestedPartner':
-                    recordReplacement = this[this.activeSuggestedRecordName].name;
-                    this.update({
-                        mentionedPartners: [['link', this[this.activeSuggestedRecordName]]],
-                    });
-                    break;
-            }
-            this.update({
+            const recordReplacement = this.activeSuggestedRecord.getMentionText();
+            const updateData = {
                 isLastStateChangeProgrammatic: true,
                 textInputContent: textLeft + recordReplacement + ' ' + textRight,
                 textInputCursorEnd: textLeft.length + recordReplacement.length + 1,
                 textInputCursorStart: textLeft.length + recordReplacement.length + 1,
-            });
+            };
+            // Specific cases for channel and partner mentions: the message with
+            // the mention will appear in the target channel, or be notified to
+            // the target partner.
+            switch (this.activeSuggestedRecord.constructor.modelName) {
+                case 'mail.thread':
+                    Object.assign(updateData, { mentionedChannels: [['link', this.activeSuggestedRecord]] });
+                    break;
+                case 'mail.partner':
+                    Object.assign(updateData, { mentionedPartners: [['link', this.activeSuggestedRecord]] });
+                    break;
+            }
+            this.update(updateData);
         }
 
         /**
@@ -221,10 +154,6 @@ function factory(dependencies) {
          * @returns {mail.partner[]}
          */
         _computeRecipients() {
-            if (this.thread && this.thread.model === 'mail.channel') {
-                // prevent from notifying/adding to followers non-members
-                return [['unlink-all']];
-            }
             const recipients = [...this.mentionedPartners];
             if (this.thread && !this.isLog) {
                 for (const recipient of this.thread.suggestedRecipientInfoList) {
@@ -382,95 +311,60 @@ function factory(dependencies) {
             }
         }
 
+        /**
+         * Sets the first suggestion as active. Main and extra records are
+         * considered together.
+         */
         setFirstSuggestionActive() {
-            if (!this[this.mainSuggestedRecordsListName][0]) {
-                if (!this[this.extraSuggestedRecordsListName][0]) {
-                    return;
-                }
-                this.update({
-                    [this.activeSuggestedRecordName]: [['link', this[this.extraSuggestedRecordsListName][0]]],
-                });
-            } else {
-                this.update({
-                    [this.activeSuggestedRecordName]: [['link', this[this.mainSuggestedRecordsListName][0]]],
-                });
-            }
+            const suggestedRecords = this.mainSuggestedRecords.concat(this.extraSuggestedRecords);
+            const firstRecord = suggestedRecords[0];
+            this.update({ activeSuggestedRecord: [['link', firstRecord]] });
         }
 
+        /**
+         * Sets the last suggestion as active. Main and extra records are
+         * considered together.
+         */
         setLastSuggestionActive() {
-            if (this[this.extraSuggestedRecordsListName].length === 0) {
-                if (this[this.mainSuggestedRecordsListName].length === 0) {
-                    return;
-                }
-                this.update({
-                    [this.activeSuggestedRecordName]: [[
-                        'link',
-                        this[this.mainSuggestedRecordsListName][this[this.mainSuggestedRecordsListName].length - 1]
-                    ]],
-                });
-                return;
-            }
-            this.update({
-                [this.activeSuggestedRecordName]: [[
-                    'link',
-                    this[this.extraSuggestedRecordsListName][this[this.extraSuggestedRecordsListName].length - 1]
-                ]],
-            });
+            const suggestedRecords = this.mainSuggestedRecords.concat(this.extraSuggestedRecords);
+            const { length, [length - 1]: lastRecord } = suggestedRecords;
+            this.update({ activeSuggestedRecord: [['link', lastRecord]] });
         }
 
+        /**
+         * Sets the next suggestion as active. Main and extra records are
+         * considered together.
+         */
         setNextSuggestionActive() {
-            const fullList = this.extraSuggestedRecordsListName ?
-                this[this.mainSuggestedRecordsListName].concat(this[this.extraSuggestedRecordsListName]) :
-                this[this.mainSuggestedRecordsListName];
-            if (fullList.length === 0) {
+            const suggestedRecords = this.mainSuggestedRecords.concat(this.extraSuggestedRecords);
+            const activeElementIndex = suggestedRecords.findIndex(
+                suggestion => suggestion === this.activeSuggestedRecord
+            );
+            if (activeElementIndex === suggestedRecords.length - 1) {
+                // loop when reaching the end of the list
+                this.setFirstSuggestionActive();
                 return;
             }
-            const activeElementIndex = fullList.findIndex(
-                suggestion => suggestion === this[this.activeSuggestedRecordName]
-            );
-            if (activeElementIndex !== fullList.length - 1) {
-                this.update({
-                    [this.activeSuggestedRecordName]: [[
-                        'link',
-                        fullList[activeElementIndex + 1]
-                    ]],
-                });
-            } else {
-                this.update({
-                    [this.activeSuggestedRecordName]: [['link', fullList[0]]],
-                });
-            }
+            const nextRecord = suggestedRecords[activeElementIndex + 1];
+            this.update({ activeSuggestedRecord: [['link', nextRecord]] });
         }
 
+        /**
+         * Sets the previous suggestion as active. Main and extra records are
+         * considered together.
+         */
         setPreviousSuggestionActive() {
-            const fullList = this.extraSuggestedRecordsListName ?
-                this[this.mainSuggestedRecordsListName].concat(this[this.extraSuggestedRecordsListName]) :
-                this[this.mainSuggestedRecordsListName];
-            if (fullList.length === 0) {
+            const suggestedRecords = this.mainSuggestedRecords.concat(this.extraSuggestedRecords);
+            const activeElementIndex = suggestedRecords.findIndex(
+                suggestion => suggestion === this.activeSuggestedRecord
+            );
+            if (activeElementIndex === 0) {
+                // loop when reaching the start of the list
+                this.setLastSuggestionActive();
                 return;
             }
-            const activeElementIndex = fullList.findIndex(
-                suggestion => suggestion === this[this.activeSuggestedRecordName]
-            );
-            if (activeElementIndex === -1) {
-                this.update({
-                    [this.activeSuggestedRecordName]: [['link', fullList[0]]]
-                });
-            } else if (activeElementIndex !== 0) {
-                this.update({
-                    [this.activeSuggestedRecordName]: [[
-                        'link',
-                        fullList[activeElementIndex - 1]
-                    ]],
-                });
-            } else {
-                this.update({
-                    [this.activeSuggestedRecordName]: [[
-                        'link',
-                        fullList[fullList.length - 1]
-                    ]],
-                });
-            }
+            const previousRecord = suggestedRecords[activeElementIndex - 1];
+            this.update({ activeSuggestedRecord: [['link', previousRecord]] });
         }
 
         //----------------------------------------------------------------------
@@ -478,11 +372,28 @@ function factory(dependencies) {
         //----------------------------------------------------------------------
 
         /**
+         * Clears the active suggested record on closing mentions or adapt it if
+         * the active current record is no longer part of the suggestions.
+         *
          * @private
          * @returns {mail.model}
          */
         _computeActiveSuggestedRecord() {
-            return this[this.activeSuggestedRecordName];
+            if (
+                this.mainSuggestedRecords.length === 0 &&
+                this.extraSuggestedRecords.length === 0
+            ) {
+                return [['unlink']];
+            }
+            if (
+                this.mainSuggestedRecords.includes(this.activeSuggestedRecord) ||
+                this.extraSuggestedRecords.includes(this.activeSuggestedRecord)
+            ) {
+                return;
+            }
+            const suggestedRecords = this.mainSuggestedRecords.concat(this.extraSuggestedRecords);
+            const firstRecord = suggestedRecords[0];
+            return [['link', firstRecord]];
         }
 
         /**
@@ -497,25 +408,18 @@ function factory(dependencies) {
         }
 
         /**
-         * Ensure extraSuggestedPartners does not contain any partner already
-         * present in mainSuggestedPartners. This is necessary for the
-         * consistency of suggestion list.
+         * Clears the extra suggested record on closing mentions, and ensures
+         * the extra list does not contain any element already present in the
+         * main list, which is a requirement for the navigation process.
          *
-         * @private
-         * @returns {mail.partner[]}
-         */
-        _computeExtraSuggestedPartners() {
-            return [['unlink', this.mainSuggestedPartners]];
-        }
-
-        /**
          * @private
          * @returns {mail.model[]}
          */
-        _computeExtraSuggestedRecordsList() {
-            return this.extraSuggestedRecordsListName
-                ? this[this.extraSuggestedRecordsListName]
-                : [];
+        _computeExtraSuggestedRecords() {
+            if (this.suggestionDelimiterPosition === undefined) {
+                return [['unlink-all']];
+            }
+            return [['unlink', this.mainSuggestedRecords]];
         }
 
         /**
@@ -523,9 +427,7 @@ function factory(dependencies) {
          * @return {boolean}
          */
         _computeHasSuggestions() {
-            const hasMainSuggestedRecordsList = this.mainSuggestedRecordsListName ? this[this.mainSuggestedRecordsListName].length > 0 : false;
-            const hasExtraSuggestedRecordsList = this.extraSuggestedRecordsListName ? this[this.extraSuggestedRecordsListName].length > 0 : false;
-            return hasMainSuggestedRecordsList || hasExtraSuggestedRecordsList;
+            return this.mainSuggestedRecords.length > 0 || this.extraSuggestedRecords.length > 0;
         }
 
         /**
@@ -537,13 +439,15 @@ function factory(dependencies) {
         }
 
         /**
+         * Clears the main suggested record on closing mentions.
+         *
          * @private
          * @returns {mail.model[]}
          */
-        _computeMainSuggestedRecordsList() {
-            return this.mainSuggestedRecordsListName
-                ? this[this.mainSuggestedRecordsListName]
-                : [];
+        _computeMainSuggestedRecords() {
+            if (this.suggestionDelimiterPosition === undefined) {
+                return [['unlink-all']];
+            }
         }
 
         /**
@@ -598,6 +502,96 @@ function factory(dependencies) {
             return [['unlink', unmentionedChannels]];
         }
 
+        /**
+         * @private
+         * @returns {string}
+         */
+        _computeSuggestionDelimiter() {
+            if (
+                this.suggestionDelimiterPosition === undefined ||
+                this.suggestionDelimiterPosition >= this.textInputContent.length
+            ) {
+                return clear();
+            }
+            return this.textInputContent[this.suggestionDelimiterPosition];
+        }
+
+        /**
+         * @private
+         * @returns {integer}
+         */
+        _computeSuggestionDelimiterPosition() {
+            if (this.textInputCursorStart !== this.textInputCursorEnd) {
+                // avoid interfering with multi-char selection
+                return clear();
+            }
+            const candidatePositions = [];
+            // keep the current delimiter if it is still valid
+            if (
+                this.suggestionDelimiterPosition !== undefined &&
+                this.suggestionDelimiterPosition < this.textInputCursorStart
+            ) {
+                candidatePositions.push(this.suggestionDelimiterPosition);
+            }
+            // consider the char before the current cursor position if the
+            // current delimiter is no longer valid (or if there is none)
+            if (this.textInputCursorStart > 0) {
+                candidatePositions.push(this.textInputCursorStart - 1);
+            }
+            const suggestionDelimiters = ['@', ':', '#', '/'];
+            for (const candidatePosition of candidatePositions) {
+                if (
+                    candidatePosition < 0 ||
+                    candidatePosition >= this.textInputContent.length
+                ) {
+                    continue;
+                }
+                const candidateChar = this.textInputContent[candidatePosition];
+                if (!suggestionDelimiters.includes(candidateChar)) {
+                    continue;
+                }
+                const charBeforeCandidate = this.textInputContent[candidatePosition - 1];
+                if (charBeforeCandidate && !/\s/.test(charBeforeCandidate)) {
+                    continue;
+                }
+                return candidatePosition;
+            }
+            return clear();
+        }
+
+        /**
+         * @private
+         * @returns {string}
+         */
+        _computeSuggestionModelName() {
+            switch (this.suggestionDelimiter) {
+                case '@':
+                    return 'mail.partner';
+                case ':':
+                    return 'mail.canned_response';
+                case '/':
+                    return 'mail.channel_command';
+                case '#':
+                    return 'mail.thread';
+                default:
+                    return clear();
+            }
+        }
+
+        /**
+         * @private
+         * @returns {string}
+         */
+        _computeSuggestionSearchTerm() {
+            if (
+                this.suggestionDelimiterPosition === undefined ||
+                this.suggestionDelimiterPosition >= this.textInputCursorStart
+            ) {
+                return clear();
+            }
+            return this.textInputContent.substring(this.suggestionDelimiterPosition + 1, this.textInputCursorStart);
+        }
+
         /**
          * Executes the given async function, only when the last function
          * executed by this method terminates. If there is already a pending
@@ -716,11 +710,45 @@ function factory(dependencies) {
             return undefined;
         }
 
+        /**
+         * Updates the suggestion state based on the currently saved composer
+         * state (in particular content and cursor position).
+         *
+         * @private
+         */
+        _onChangeUpdateSuggestionList() {
+            // Update the suggestion list immediately for a reactive UX...
+            this._updateSuggestionList();
+            // ...and then update it again after the server returned data.
+            this._executeOrQueueFunction(async () => {
+                if (
+                    this.suggestionDelimiterPosition === undefined ||
+                    this.suggestionSearchTerm === undefined ||
+                    !this.suggestionModelName
+                ) {
+                    // ignore obsolete call
+                    return;
+                }
+                const Model = this.env.models[this.suggestionModelName];
+                const searchTerm = this.suggestionSearchTerm;
+                await this.async(() => Model.fetchSuggestions(searchTerm, { thread: this.thread }));
+                this._updateSuggestionList();
+                if (
+                    this.suggestionSearchTerm &&
+                    this.suggestionSearchTerm === searchTerm &&
+                    this.suggestionModelName &&
+                    this.env.models[this.suggestionModelName] === Model &&
+                    !this.hasSuggestions
+                ) {
+                    this.closeSuggestions();
+                }
+            });
+        }
+
         /**
          * @private
          */
         _reset() {
-            this.closeSuggestions();
             this.update({
                 attachments: [['unlink-all']],
                 isLastStateChangeProgrammatic: true,
@@ -734,200 +762,58 @@ function factory(dependencies) {
         }
 
         /**
-         * @private
-         * @param {string} mentionKeyword
-         */
-        _updateSuggestedCannedResponses(mentionKeyword) {
-            this.update({
-                suggestedCannedResponses: [['replace', this.env.messaging.cannedResponses.filter(
-                    cannedResponse => cannedResponse.source.includes(mentionKeyword)
-                )]],
-            });
-
-            if (this.suggestedCannedResponses[0]) {
-                this.update({
-                    activeSuggestedCannedResponse: [['link', this.suggestedCannedResponses[0]]],
-                    hasToScrollToActiveSuggestion: true,
-                });
-            } else {
-                this.update({
-                    activeSuggestedCannedResponse: [['unlink']],
-                });
-            }
-        }
-
-        /**
-         * @private
-         * @param {string} mentionKeyword
-         */
-        async _updateSuggestedChannels(mentionKeyword) {
-            const mentions = await this.async(() => this.env.services.rpc(
-                {
-                    model: 'mail.channel',
-                    method: 'get_mention_suggestions',
-                    kwargs: {
-                        limit: 8,
-                        search: mentionKeyword,
-                    },
-                },
-                { shadow: true }
-            ));
-
-            this.update({
-                suggestedChannels: [[
-                    'insert-and-replace',
-                    mentions.map(data => {
-                        const threadData = this.env.models['mail.thread'].convertData(data);
-                        return Object.assign({ model: 'mail.channel' }, threadData);
-                    })
-                ]],
-            });
-
-            if (this.suggestedChannels[0]) {
-                this.update({
-                    activeSuggestedChannel: [['link', this.suggestedChannels[0]]],
-                    hasToScrollToActiveSuggestion: true,
-                });
-            } else {
-                this.update({
-                    activeSuggestedChannel: [['unlink']],
-                });
-            }
-        }
-
-        /**
-         * @param {string} mentionKeyword
-         */
-        _updateSuggestedChannelCommands(mentionKeyword) {
-            const commands = this.env.messaging.commands.filter(command => {
-                if (!command.name.includes(mentionKeyword)) {
-                    return false;
-                }
-                if (command.channel_types) {
-                    return command.channel_types.includes(this.thread.channel_type);
-                }
-                return true;
-            });
-            this.update({ suggestedChannelCommands: [['replace', commands]] });
-            if (this.suggestedChannelCommands[0]) {
-                this.update({
-                    activeSuggestedChannelCommand: [['link', this.suggestedChannelCommands[0]]],
-                    hasToScrollToActiveSuggestion: true,
-                });
-            } else {
-                this.update({
-                    activeSuggestedChannelCommand: [['unlink']],
-                });
-            }
-        }
-
-        /**
-         * @private
-         * @param {string} mentionKeyword
-         */
-        async _updateSuggestedPartners(mentionKeyword) {
-            const mentions = await this.async(() => this.env.services.rpc(
-                {
-                    model: 'res.partner',
-                    method: 'get_mention_suggestions',
-                    kwargs: {
-                        limit: 8,
-                        search: mentionKeyword,
-                    },
-                },
-                { shadow: true }
-            ));
-
-            const mainSuggestedPartners = mentions[0];
-            const extraSuggestedPartners = mentions[1];
-            this.update({
-                extraSuggestedPartners: [[
-                    'insert-and-replace',
-                    extraSuggestedPartners.map(data =>
-                        this.env.models['mail.partner'].convertData(data)
-                    )
-                ]],
-                mainSuggestedPartners: [[
-                    'insert-and-replace',
-                    mainSuggestedPartners.map(data =>
-                        this.env.models['mail.partner'].convertData(data))
-                    ]],
-            });
-
-            if (this.mainSuggestedPartners[0]) {
-                this.update({
-                    activeSuggestedPartner: [['link', this.mainSuggestedPartners[0]]],
-                    hasToScrollToActiveSuggestion: true,
-                });
-            } else if (this.extraSuggestedPartners[0]) {
-                this.update({
-                    activeSuggestedPartner: [['link', this.extraSuggestedPartners[0]]],
-                    hasToScrollToActiveSuggestion: true,
-                });
-            } else {
-                this.update({
-                    activeSuggestedPartner: [['unlink']],
-                });
-            }
-        }
-
-        /**
-         * Validates user's current typing as a correct mention keyword in order
-         * to trigger mentions suggestions display.
-         * Returns the mention keyword without the suggestion delimiter if it
-         * has been validated and false if not.
+         * Updates the current suggestion list. This method should be called
+         * whenever the UI has to be refreshed following change in state.
+         *
+         * This method should ideally be a compute, but its dependencies are
+         * currently too complex to express due to accessing plenty of fields
+         * from all records of dynamic models.
          *
          * @private
-         * @param {boolean} beginningOnly
-         * @returns {string|boolean}
          */
-        _validateMentionKeyword(beginningOnly) {
-            const leftString = this.textInputContent.substring(0, this.textInputCursorStart);
-
-            // use position before suggestion delimiter because there should be whitespaces
-            // or line feed/carriage return before the suggestion delimiter
-            const beforeSuggestionDelimiterPosition = leftString.lastIndexOf(this.suggestionDelimiter) - 1;
-            if (beginningOnly && beforeSuggestionDelimiterPosition > 0) {
-                return false;
+        _updateSuggestionList() {
+            if (
+                this.suggestionDelimiterPosition === undefined ||
+                this.suggestionSearchTerm === undefined ||
+                !this.suggestionModelName
+            ) {
+                return;
             }
-            let searchStr = this.textInputContent.substring(
-                beforeSuggestionDelimiterPosition,
-                this.textInputCursorStart
-            );
-            // regex string start with suggestion delimiter or whitespace then suggestion delimiter
-            const pattern = "^" + this.suggestionDelimiter + "|^\\s" + this.suggestionDelimiter;
-            const regexStart = new RegExp(pattern, 'g');
-            // trim any left whitespaces or the left line feed/ carriage return
-            // at the beginning of the string
-            searchStr = searchStr.replace(/^\s\s*|^[\n\r]/g, '');
-            if (regexStart.test(searchStr) && searchStr.length) {
-                searchStr = searchStr.replace(pattern, '');
-                return !searchStr.includes(' ') && !/[\r\n]/.test(searchStr)
-                    ? searchStr.replace(this.suggestionDelimiter, '')
-                    : false;
-            }
-            return false;
+            const Model = this.env.models[this.suggestionModelName];
+            const [
+                mainSuggestedRecords,
+                extraSuggestedRecords = [],
+            ] = Model.searchSuggestions(this.suggestionSearchTerm, { thread: this.thread });
+            const sortFunction = Model.getSuggestionSortFunction(this.suggestionSearchTerm, { thread: this.thread });
+            mainSuggestedRecords.sort(sortFunction);
+            extraSuggestedRecords.sort(sortFunction);
+            // arbitrary limit to avoid displaying too many elements at once
+            // ideally a load more mechanism should be introduced
+            const limit = 8;
+            mainSuggestedRecords.length = Math.min(mainSuggestedRecords.length, limit);
+            extraSuggestedRecords.length = Math.min(extraSuggestedRecords.length, limit - mainSuggestedRecords.length);
+            this.update({
+                extraSuggestedRecords: [['replace', extraSuggestedRecords]],
+                hasToScrollToActiveSuggestion: true,
+                mainSuggestedRecords: [['replace', mainSuggestedRecords]],
+            });
         }
     }
 
     Composer.fields = {
-        activeSuggestedCannedResponse: many2one('mail.canned_response'),
-        activeSuggestedChannel: many2one('mail.thread'),
-        activeSuggestedChannelCommand: many2one('mail.channel_command'),
-        activeSuggestedPartner: many2one('mail.partner'),
-        activeSuggestedRecord: attr({
+        /**
+         * Determines the suggested record that is currently active. This record
+         * is highlighted in the UI and it will be the selected record if the
+         * suggestion is confirmed by the user.
+         */
+        activeSuggestedRecord: many2one('mail.model', {
             compute: '_computeActiveSuggestedRecord',
             dependencies: [
-                'activeSuggestedCannedResponse',
-                'activeSuggestedChannel',
-                'activeSuggestedChannelCommand',
-                'activeSuggestedPartner',
-                'activeSuggestedRecordName',
+                'activeSuggestedRecord',
+                'extraSuggestedRecords',
+                'mainSuggestedRecords',
             ],
         }),
-        activeSuggestedRecordName: attr({
-           default: "",
-        }),
         attachments: many2many('mail.attachment', {
             inverse: 'composers',
         }),
@@ -958,26 +844,19 @@ function factory(dependencies) {
         discussAsReplying: one2one('mail.discuss', {
             inverse: 'replyingToMessageOriginThreadComposer',
         }),
-        extraSuggestedPartners: many2many('mail.partner', {
-            compute: '_computeExtraSuggestedPartners',
-            dependencies: [
-                'extraSuggestedPartners',
-                'mainSuggestedPartners',
-            ],
-        }),
-        extraSuggestedRecordsList: attr({
-            compute: '_computeExtraSuggestedRecordsList',
-            dependencies: [
-                'extraSuggestedPartners',
-                'extraSuggestedRecordsListName',
-            ],
-        }),
         /**
-         * Allows to have different model types of mentions through a dynamic process
-         * RPC can provide 2 lists and the second is defined as "extra"
+         * Determines the extra records that are currently suggested.
+         * Allows to have different model types of mentions through a dynamic
+         * process. 2 arbitrary lists can be provided and the second is defined
+         * as "extra".
          */
-        extraSuggestedRecordsListName: attr({
-           default: "",
+        extraSuggestedRecords: many2many('mail.model', {
+            compute: '_computeExtraSuggestedRecords',
+            dependencies: [
+                'extraSuggestedRecords',
+                'mainSuggestedRecords',
+                'suggestionDelimiterPosition',
+            ],
         }),
         /**
          * This field determines whether some attachments linked to this
@@ -993,16 +872,15 @@ function factory(dependencies) {
         hasFocus: attr({
             default: false,
         }),
+        /**
+         * States whether there is any result currently found for the current
+         * suggestion delimiter and search term, if applicable.
+         */
         hasSuggestions: attr({
             compute: '_computeHasSuggestions',
             dependencies: [
-                'extraSuggestedRecordsListName',
-                'extraSuggestedPartners',
-                'mainSuggestedRecordsListName',
-                'mainSuggestedPartners',
-                'suggestedCannedResponses',
-                'suggestedChannelCommands',
-                'suggestedChannels',
+                'extraSuggestedRecords',
+                'mainSuggestedRecords',
             ],
             default: false,
         }),
@@ -1033,31 +911,49 @@ function factory(dependencies) {
          * Determines whether a post_message request is currently pending.
          */
         isPostingMessage: attr(),
-        mainSuggestedRecordsList: attr({
-            compute: '_computeMainSuggestedRecordsList',
+        /**
+         * Determines the main records that are currently suggested.
+         * Allows to have different model types of mentions through a dynamic
+         * process. 2 arbitrary lists can be provided and the first is defined
+         * as "main".
+         */
+        mainSuggestedRecords: many2many('mail.model', {
+            compute: '_computeMainSuggestedRecords',
             dependencies: [
-                'mainSuggestedPartners',
-                'mainSuggestedRecordsListName',
-                'suggestedCannedResponses',
-                'suggestedChannelCommands',
-                'suggestedChannels',
+                'mainSuggestedRecords',
+                'suggestionDelimiterPosition',
             ],
         }),
-        /**
-         * Allows to have different model types of mentions through a dynamic process
-         * RPC can provide 2 lists and the first is defined as "main"
-         */
-        mainSuggestedRecordsListName: attr({
-           default: "",
-        }),
-        mainSuggestedPartners: many2many('mail.partner'),
         mentionedChannels: many2many('mail.thread', {
             compute: '_computeMentionedChannels',
             dependencies: ['textInputContent'],
         }),
         mentionedPartners: many2many('mail.partner', {
             compute: '_computeMentionedPartners',
-            dependencies: ['textInputContent'],
+            dependencies: [
+                'mentionedPartners',
+                'mentionedPartnersName',
+                'textInputContent',
+            ],
+        }),
+        /**
+         * Serves as compute dependency.
+         */
+        mentionedPartnersName: attr({
+            related: 'mentionedPartners.name',
+        }),
+        /**
+         * Not a real field, used to trigger `_onChangeUpdateSuggestionList`
+         * when one of the dependencies changes.
+         */
+        onChangeUpdateSuggestionList: attr({
+            compute: '_onChangeUpdateSuggestionList',
+            dependencies: [
+                'suggestionDelimiterPosition',
+                'suggestionModelName',
+                'suggestionSearchTerm',
+                'thread',
+            ],
         }),
         /**
          * Determines the extra `mail.partner` (on top of existing followers)
@@ -1093,18 +989,54 @@ function factory(dependencies) {
         subjectContent: attr({
             default: "",
         }),
-        suggestedCannedResponses: many2many('mail.canned_response'),
-        suggestedChannelCommands: many2many('mail.channel_command'),
-        suggestedChannels: many2many('mail.thread'),
         /**
-         * Special character used to trigger different kinds of suggestions
-         * such as canned responses (:), channels (#), commands (/) and partners (@)
+         * States which type of suggestion is currently in progress, if any.
+         * The value of this field contains the magic char that corresponds to
+         * the suggestion currently in progress, and it must be one of these:
+         * canned responses (:), channels (#), commands (/) and partners (@)
          */
         suggestionDelimiter: attr({
-            default: "",
+            compute: '_computeSuggestionDelimiter',
+            dependencies: [
+                'suggestionDelimiterPosition',
+                'textInputContent',
+            ],
         }),
+        /**
+         * States the position inside textInputContent of the suggestion
+         * delimiter currently in consideration. Useful if the delimiter char
+         * appears multiple times in the content.
+         * Note: the position is 0 based so it's important to compare to
+         * `undefined` when checking for the absence of a value.
+         */
+        suggestionDelimiterPosition: attr({
+            compute: '_computeSuggestionDelimiterPosition',
+            dependencies: [
+                'textInputContent',
+                'textInputCursorEnd',
+                'textInputCursorStart',
+            ],
+        }),
+        /**
+         * States the target model name of the suggestion currently in progress,
+         * if any.
+         */
         suggestionModelName: attr({
-           default: "",
+            compute: '_computeSuggestionModelName',
+            dependencies: [
+                'suggestionDelimiter',
+            ],
+        }),
+        /**
+         * States the search term to use for suggestions (if any).
+         */
+        suggestionSearchTerm: attr({
+            compute: '_computeSuggestionSearchTerm',
+            dependencies: [
+                'suggestionDelimiterPosition',
+                'textInputContent',
+                'textInputCursorStart',
+            ],
         }),
         textInputContent: attr({
             default: "",
diff --git a/addons/mail/static/src/models/messaging_initializer/messaging_initializer.js b/addons/mail/static/src/models/messaging_initializer/messaging_initializer.js
index 86522d1cb3f..dee2dbaeb24 100644
--- a/addons/mail/static/src/models/messaging_initializer/messaging_initializer.js
+++ b/addons/mail/static/src/models/messaging_initializer/messaging_initializer.js
@@ -231,11 +231,8 @@ function factory(dependencies) {
          * @param {Object[]} mentionPartnerSuggestionsData
          */
         async _initMentionPartnerSuggestions(mentionPartnerSuggestionsData) {
-            return executeGracefully(mentionPartnerSuggestionsData.map(suggestions => () => {
-                return executeGracefully(suggestions.map(suggestion => () => {
-                    const { email, id, name } = suggestion;
-                    this.env.models['mail.partner'].insert({ email, id, name });
-                }));
+            return executeGracefully(mentionPartnerSuggestionsData.map(partnerData => () => {
+                this.env.models['mail.partner'].insert(this.env.models['mail.partner'].convertData(partnerData));
             }));
         }
 
diff --git a/addons/mail/static/src/models/partner/partner.js b/addons/mail/static/src/models/partner/partner.js
index ee54e0fa2de..b86040dda6c 100644
--- a/addons/mail/static/src/models/partner/partner.js
+++ b/addons/mail/static/src/models/partner/partner.js
@@ -3,8 +3,7 @@ odoo.define('mail/static/src/models/partner/partner.js', function (require) {
 
 const { registerNewModel } = require('mail/static/src/model/model_core.js');
 const { attr, many2many, many2one, one2many, one2one } = require('mail/static/src/model/model_field.js');
-
-const utils = require('web.utils');
+const { cleanSearchTerm } = require('mail/static/src/utils/utils.js');
 
 function factory(dependencies) {
 
@@ -67,6 +66,7 @@ function factory(dependencies) {
                             id: data.user_id,
                         };
                     }
+                    user.isInternalUser = data.is_internal_user;
                     data2.user = [['insert', user]];
                 }
             }
@@ -74,6 +74,38 @@ function factory(dependencies) {
             return data2;
         }
 
+        /**
+         * Fetches partners matching the given search term to extend the
+         * JS knowledge and to update the suggestion list accordingly.
+         *
+         * @static
+         * @param {string} searchTerm
+         * @param {Object} [options={}]
+         * @param {mail.thread} [options.thread] prioritize and/or restrict
+         *  result in the context of given thread
+         */
+        static async fetchSuggestions(searchTerm, { thread } = {}) {
+            const kwargs = { search: searchTerm };
+            const isNonPublicChannel = thread && thread.model === 'mail.channel' && thread.public !== 'public';
+            if (isNonPublicChannel) {
+                kwargs.channel_id = thread.id;
+            }
+            const suggestedPartners = await this.env.services.rpc(
+                {
+                    model: 'res.partner',
+                    method: 'get_mention_suggestions',
+                    kwargs,
+                },
+                { shadow: true },
+            );
+            const partners = this.env.models['mail.partner'].insert(suggestedPartners.map(data =>
+                this.env.models['mail.partner'].convertData(data)
+            ));
+            if (isNonPublicChannel) {
+                thread.update({ members: [['link', partners]] });
+            }
+        }
+
         /**
          * Search for partners matching `keyword`.
          *
@@ -86,17 +118,15 @@ function factory(dependencies) {
         static async imSearch({ callback, keyword, limit = 10 }) {
             // prefetched partners
             let partners = [];
-            const searchRegexp = new RegExp(
-                _.str.escapeRegExp(utils.unaccent(keyword)),
-                'i'
-            );
+            const cleanedSearchTerm = cleanSearchTerm(keyword);
             const currentPartner = this.env.messaging.currentPartner;
             for (const partner of this.all(partner => partner.active)) {
                 if (partners.length < limit) {
                     if (
                         partner !== currentPartner &&
-                        searchRegexp.test(partner.name) &&
-                        partner.user
+                        partner.name &&
+                        partner.user &&
+                        cleanSearchTerm(partner.name).includes(cleanedSearchTerm)
                     ) {
                         partners.push(partner);
                     }
@@ -119,6 +149,56 @@ function factory(dependencies) {
             callback(partners);
         }
 
+        /**
+         * Returns partners that match the given search term.
+         *
+         * @static
+         * @param {string} searchTerm
+         * @param {Object} [options={}]
+         * @param {mail.thread} [options.thread] prioritize and/or restrict
+         *  result in the context of given thread
+         * @returns {[mail.partner[], mail.partner[]]}
+         */
+        static searchSuggestions(searchTerm, { thread } = {}) {
+            let partners;
+            const isNonPublicChannel = thread && thread.model === 'mail.channel' && thread.public !== 'public';
+            if (isNonPublicChannel) {
+                // Only return the channel members when in the context of a
+                // non-public channel. Indeed, the message with the mention
+                // would be notified to the mentioned partner, so this prevents
+                // from inadvertently leaking the private message to the
+                // mentioned partner.
+                partners = thread.members;
+            } else {
+                partners = this.env.models['mail.partner'].all();
+            }
+            const cleanedSearchTerm = cleanSearchTerm(searchTerm);
+            const mainSuggestionList = [];
+            const extraSuggestionList = [];
+            for (const partner of partners) {
+                if (
+                    (!partner.active && partner !== this.env.messaging.partnerRoot) ||
+                    partner.id <= 0 ||
+                    this.env.messaging.publicPartners.includes(partner)
+                ) {
+                    // ignore archived partners (except OdooBot), temporary
+                    // partners (livechat guests), public partners (technical)
+                    continue;
+                }
+                if (
+                    (partner.nameOrDisplayName && cleanSearchTerm(partner.nameOrDisplayName).includes(cleanedSearchTerm)) ||
+                    (partner.email && cleanSearchTerm(partner.email).includes(cleanedSearchTerm))
+                ) {
+                    if (partner.user) {
+                        mainSuggestionList.push(partner);
+                    } else {
+                        extraSuggestionList.push(partner);
+                    }
+                }
+            }
+            return [mainSuggestionList, extraSuggestionList];
+        }
+
         /**
          * @static
          */
@@ -168,6 +248,89 @@ function factory(dependencies) {
             return this.user.getChat();
         }
 
+        /**
+         * Returns the text that identifies this partner in a mention.
+         *
+         * @returns {string}
+         */
+        getMentionText() {
+            return this.name;
+        }
+
+        /**
+         * Returns a sort function to determine the order of display of partners
+         * in the suggestion list.
+         *
+         * @static
+         * @param {string} searchTerm
+         * @param {Object} [options={}]
+         * @param {mail.thread} [options.thread] prioritize result in the
+         *  context of given thread
+         * @returns {function}
+         */
+        static getSuggestionSortFunction(searchTerm, { thread } = {}) {
+            const cleanedSearchTerm = cleanSearchTerm(searchTerm);
+            return (a, b) => {
+                const isAInternalUser = a.user && a.user.isInternalUser;
+                const isBInternalUser = b.user && b.user.isInternalUser;
+                if (isAInternalUser && !isBInternalUser) {
+                    return -1;
+                }
+                if (!isAInternalUser && isBInternalUser) {
+                    return 1;
+                }
+                if (thread && thread.model === 'mail.channel') {
+                    const isAMember = thread.members.includes(a);
+                    const isBMember = thread.members.includes(b);
+                    if (isAMember && !isBMember) {
+                        return -1;
+                    }
+                    if (!isAMember && isBMember) {
+                        return 1;
+                    }
+                }
+                if (thread) {
+                    const isAFollower = thread.followersPartner.includes(a);
+                    const isBFollower = thread.followersPartner.includes(b);
+                    if (isAFollower && !isBFollower) {
+                        return -1;
+                    }
+                    if (!isAFollower && isBFollower) {
+                        return 1;
+                    }
+                }
+                const cleanedAName = cleanSearchTerm(a.nameOrDisplayName || '');
+                const cleanedBName = cleanSearchTerm(b.nameOrDisplayName || '');
+                if (cleanedAName.startsWith(cleanedSearchTerm) && !cleanedBName.startsWith(cleanedSearchTerm)) {
+                    return -1;
+                }
+                if (!cleanedAName.startsWith(cleanedSearchTerm) && cleanedBName.startsWith(cleanedSearchTerm)) {
+                    return 1;
+                }
+                if (cleanedAName < cleanedBName) {
+                    return -1;
+                }
+                if (cleanedAName > cleanedBName) {
+                    return 1;
+                }
+                const cleanedAEmail = cleanSearchTerm(a.email || '');
+                const cleanedBEmail = cleanSearchTerm(b.email || '');
+                if (cleanedAEmail.startsWith(cleanedSearchTerm) && !cleanedAEmail.startsWith(cleanedSearchTerm)) {
+                    return -1;
+                }
+                if (!cleanedBEmail.startsWith(cleanedSearchTerm) && cleanedBEmail.startsWith(cleanedSearchTerm)) {
+                    return 1;
+                }
+                if (cleanedAEmail < cleanedBEmail) {
+                    return -1;
+                }
+                if (cleanedAEmail > cleanedBEmail) {
+                    return 1;
+                }
+                return a.id - b.id;
+            };
+        }
+
         /**
          * Opens a chat between the user of this partner and the current user
          * and returns it.
diff --git a/addons/mail/static/src/models/thread/thread.js b/addons/mail/static/src/models/thread/thread.js
index b02f4a2739e..6a9fc378efb 100644
--- a/addons/mail/static/src/models/thread/thread.js
+++ b/addons/mail/static/src/models/thread/thread.js
@@ -6,6 +6,7 @@ const { attr, many2many, many2one, one2many, one2one } = require('mail/static/sr
 const { clear } = require('mail/static/src/model/model_field_command.js');
 const throttle = require('mail/static/src/utils/throttle/throttle.js');
 const Timer = require('mail/static/src/utils/timer/timer.js');
+const { cleanSearchTerm } = require('mail/static/src/utils/utils.js');
 const mailUtils = require('mail.utils');
 
 function factory(dependencies) {
@@ -279,6 +280,82 @@ function factory(dependencies) {
             return data2;
         }
 
+        /**
+         * Fetches threads matching the given composer search state to extend
+         * the JS knowledge and to update the suggestion list accordingly.
+         * More specifically only thread of model 'mail.channel' are fetched.
+         *
+         * @static
+         * @param {string} searchTerm
+         * @param {Object} [options={}]
+         * @param {mail.thread} [options.thread] prioritize and/or restrict
+         *  result in the context of given thread
+         */
+        static async fetchSuggestions(searchTerm, { thread } = {}) {
+            const channelsData = await this.env.services.rpc(
+                {
+                    model: 'mail.channel',
+                    method: 'get_mention_suggestions',
+                    kwargs: { search: searchTerm },
+                },
+                { shadow: true },
+            );
+            this.env.models['mail.thread'].insert(channelsData.map(channelData =>
+                Object.assign(
+                    { model: 'mail.channel' },
+                    this.env.models['mail.thread'].convertData(channelData),
+                )
+            ));
+        }
+
+        /**
+         * Returns a sort function to determine the order of display of threads
+         * in the suggestion list.
+         *
+         * @static
+         * @param {string} searchTerm
+         * @param {Object} [options={}]
+         * @param {mail.thread} [options.thread] prioritize result in the
+         *  context of given thread
+         * @returns {function}
+         */
+        static getSuggestionSortFunction(searchTerm, { thread } = {}) {
+            const cleanedSearchTerm = cleanSearchTerm(searchTerm);
+            return (a, b) => {
+                const isAPublic = a.model === 'mail.channel' && a.public === 'public';
+                const isBPublic = b.model === 'mail.channel' && b.public === 'public';
+                if (isAPublic && !isBPublic) {
+                    return -1;
+                }
+                if (!isAPublic && isBPublic) {
+                    return 1;
+                }
+                const isMemberOfA = a.model === 'mail.channel' && a.members.includes(this.env.messaging.currentPartner);
+                const isMemberOfB = b.model === 'mail.channel' && b.members.includes(this.env.messaging.currentPartner);
+                if (isMemberOfA && !isMemberOfB) {
+                    return -1;
+                }
+                if (!isMemberOfA && isMemberOfB) {
+                    return 1;
+                }
+                const cleanedAName = cleanSearchTerm(a.name || '');
+                const cleanedBName = cleanSearchTerm(b.name || '');
+                if (cleanedAName.startsWith(cleanedSearchTerm) && !cleanedBName.startsWith(cleanedSearchTerm)) {
+                    return -1;
+                }
+                if (!cleanedAName.startsWith(cleanedSearchTerm) && cleanedBName.startsWith(cleanedSearchTerm)) {
+                    return 1;
+                }
+                if (cleanedAName < cleanedBName) {
+                    return -1;
+                }
+                if (cleanedAName > cleanedBName) {
+                    return 1;
+                }
+                return a.id - b.id;
+            };
+        }
+
         /**
          * Load the previews of the specified threads. Basically, it fetches the
          * last messages, since they are used to display inline content of them.
@@ -548,6 +625,41 @@ function factory(dependencies) {
             }
         }
 
+        /*
+         * Returns threads that match the given search term. More specially only
+         * threads of model 'mail.channel' are suggested, and if the context
+         * thread is a private channel, only itself is returned if it matches
+         * the search term.
+         *
+         * @static
+         * @param {string} searchTerm
+         * @param {Object} [options={}]
+         * @param {mail.thread} [options.thread] prioritize and/or restrict
+         *  result in the context of given thread
+         * @returns {[mail.threads[], mail.threads[]]}
+         */
+        static searchSuggestions(searchTerm, { thread } = {}) {
+            let threads;
+            if (thread && thread.model === 'mail.channel' && thread.public !== 'public') {
+                // Only return the current channel when in the context of a
+                // non-public channel. Indeed, the message with the mention
+                // would appear in the target channel, so this prevents from
+                // inadvertently leaking the private message into the mentioned
+                // channel.
+                threads = [thread];
+            } else {
+                threads = this.env.models['mail.thread'].all();
+            }
+            const cleanedSearchTerm = cleanSearchTerm(searchTerm);
+            return [threads.filter(thread =>
+                !thread.isTemporary &&
+                thread.model === 'mail.channel' &&
+                thread.channel_type === 'channel' &&
+                thread.name &&
+                cleanSearchTerm(thread.name).includes(cleanedSearchTerm)
+            )];
+        }
+
         /**
          * @param {string} [stringifiedDomain='[]']
          * @returns {mail.thread_cache}
@@ -613,6 +725,15 @@ function factory(dependencies) {
             this.fetchAndUpdateSuggestedRecipients();
         }
 
+        /**
+         * Returns the text that identifies this thread in a mention.
+         *
+         * @returns {string}
+         */
+        getMentionText() {
+            return this.name;
+        }
+
         /**
          * Load new messages on the main cache of this thread.
          */
diff --git a/addons/mail/static/src/models/user/user.js b/addons/mail/static/src/models/user/user.js
index 2bf958bdbd8..298074f0315 100644
--- a/addons/mail/static/src/models/user/user.js
+++ b/addons/mail/static/src/models/user/user.js
@@ -206,6 +206,12 @@ function factory(dependencies) {
         id: attr({
             required: true,
         }),
+        /**
+         * Determines whether this user is an internal user. An internal user is
+         * a member of the group `base.group_user`. This is the inverse of the
+         * `share` field in python.
+         */
+        isInternalUser: attr(),
         display_name: attr({
             compute: '_computeDisplayName',
             dependencies: [
diff --git a/addons/mail/static/src/utils/utils.js b/addons/mail/static/src/utils/utils.js
index 06a99ed11c8..c62dd0c0086 100644
--- a/addons/mail/static/src/utils/utils.js
+++ b/addons/mail/static/src/utils/utils.js
@@ -4,6 +4,7 @@ odoo.define('mail/static/src/utils/utils.js', function (require) {
 const { delay } = require('web.concurrency');
 const {
     patch: webUtilsPatch,
+    unaccent,
     unpatch: webUtilsUnpatch,
 } = require('web.utils');
 
@@ -14,6 +15,18 @@ const {
 const classPatchMap = new WeakMap();
 const eventHandledWeakMap = new WeakMap();
 
+/**
+ * Returns the given string after cleaning it. The goal of the clean is to give
+ * more convenient results when comparing it to potential search results, on
+ * which the clean should also be called before comparing them.
+ *
+ * @param {string} searchTerm
+ * @returns {string}
+ */
+function cleanSearchTerm(searchTerm) {
+    return unaccent(searchTerm.toLowerCase());
+}
+
 /**
  * Executes the provided functions in order, but with a potential delay between
  * them if they take too much time. This is done in order to avoid blocking the
@@ -166,6 +179,7 @@ function unpatchInstanceMethods(Class, patchName) {
 //------------------------------------------------------------------------------
 
 return {
+    cleanSearchTerm,
     executeGracefully,
     isEventHandled,
     markEventHandled,
diff --git a/addons/mail/static/tests/helpers/mock_server.js b/addons/mail/static/tests/helpers/mock_server.js
index c358a548e7a..fd47bb88afb 100644
--- a/addons/mail/static/tests/helpers/mock_server.js
+++ b/addons/mail/static/tests/helpers/mock_server.js
@@ -1690,7 +1690,7 @@ MockServer.include({
          * @param {integer} limit
          * @returns {Object[]}
          */
-        const mentionSuggestionsFilter = function (partners, search, limit) {
+        const mentionSuggestionsFilter = (partners, search, limit) => {
             const matchingPartners = partners
                 .filter(partner => {
                     // no search term is considered as return all
@@ -1705,14 +1705,7 @@ MockServer.include({
                         return true;
                     }
                     return false;
-                }).map(partner => {
-                    // expected format
-                    return {
-                        email: partner.email,
-                        id: partner.id,
-                        name: partner.name,
-                    };
-                });
+                }).map(partner => this._mockResPartnerMailPartnerFormat(partner.id));
             // reduce results to max limit
             matchingPartners.length = Math.min(matchingPartners.length, limit);
             return matchingPartners;
@@ -1726,11 +1719,12 @@ MockServer.include({
 
         let extraMatchingPartners = [];
         // if not enough results add extra suggestions based on partners
+        const remainingLimit = limit - mainMatchingPartners.length;
         if (mainMatchingPartners.length < limit) {
             const partners = this._getRecords('res.partner', [['id', 'not in', mainMatchingPartners.map(partner => partner.id)]]);
-            extraMatchingPartners = mentionSuggestionsFilter(partners, search, limit);
+            extraMatchingPartners = mentionSuggestionsFilter(partners, search, remainingLimit);
         }
-        return [mainMatchingPartners, extraMatchingPartners];
+        return mainMatchingPartners.concat(extraMatchingPartners);
     },
     /**
      * Simulates `get_needaction_count` on `res.partner`.
@@ -1798,9 +1792,12 @@ MockServer.include({
             [['id', '=', id]],
             { active_test: false }
         )[0];
+        // Servers is also returning `user_id` and `is_internal_user` but not
+        // done here for simplification.
         return {
             "active": partner.active,
             "display_name": partner.display_name,
+            "email": partner.email,
             "id": partner.id,
             "im_status": partner.im_status,
             "name": partner.name,