@oneuptime/common 14.0.8 → 14.0.10

package/build/dist/Server/Utils/Workspace/MicrosoftTeams/MicrosoftTeams.js

@@ -30,11 +30,12 @@ import UserService from "../../../Services/UserService";
 import QueryHelper from "../../../Types/Database/QueryHelper";
 import SortOrder from "../../../../Types/BaseDatabase/SortOrder";
 import LIMIT_MAX from "../../../../Types/Database/LimitMax";
+import { truncateToLength } from "../../Database/TruncateColumnValue";
 // Bot Framework SDK imports
 import { CloudAdapter, ConfigurationBotFrameworkAuthentication, TeamsActivityHandler, TeamsInfo, MessageFactory, } from "botbuilder";
 import MicrosoftTeamsServiceUrl from "./MicrosoftTeamsServiceUrl";
 // Teams action handlers and types
-import MicrosoftTeamsAuthAction from "./Actions/Auth";
+import MicrosoftTeamsAuthAction, { MicrosoftTeamsAccountNotLinkedException, } from "./Actions/Auth";
 import MicrosoftTeamsIncidentActions from "./Actions/Incident";
 import MicrosoftTeamsAlertActions from "./Actions/Alert";
 import MicrosoftTeamsAlertEpisodeActions from "./Actions/AlertEpisode";
@@ -42,6 +43,10 @@ import MicrosoftTeamsIncidentEpisodeActions from "./Actions/IncidentEpisode";
 import MicrosoftTeamsMonitorActions from "./Actions/Monitor";
 import MicrosoftTeamsScheduledMaintenanceActions from "./Actions/ScheduledMaintenance";
 import MicrosoftTeamsOnCallDutyActions from "./Actions/OnCallDutyPolicy";
+import MicrosoftTeamsActivityDeduplicator from "./MicrosoftTeamsActivityDeduplicator";
+import MicrosoftTeamsCreateCommands from "./MicrosoftTeamsCreateCommands";
+import MicrosoftTeamsMessageSize from "./MicrosoftTeamsMessageSize";
+import MicrosoftTeamsReplies from "./MicrosoftTeamsReplies";
 import WorkspaceActionAuthorization from "../WorkspaceActionAuthorization";
 import NotAuthorizedException from "../../../../Types/Exception/NotAuthorizedException";
 import AIService, { AI_DISABLED_MESSAGE } from "../../../Services/AIService";
@@ -79,6 +84,38 @@ export var MicrosoftTeamsAppInstallState;
  * literal too.
  */
 export const MICROSOFT_TEAMS_INSTALL_READ_PERMISSION = "TeamsAppInstallation.ReadForTeam.All";
+/*
+ * The resource-specific (per chat) permission that lets OneUptime read a group
+ * chat's name (its Graph "topic") with the app-only token. Bot Framework
+ * activities from group chats do not reliably carry the name, so without this
+ * a group chat can only be named after its members. It is granted per chat
+ * when the app is installed or updated there with a manifest that requests it.
+ * (The tenant-wide Chat.ReadBasic.WhereInstalled application permission works
+ * with the same call, for admins who would rather grant it once.)
+ */
+export const MICROSOFT_TEAMS_CHAT_TOPIC_READ_PERMISSION = "ChatSettings.Read.Chat";
+export var MicrosoftTeamsChatTopicLookupStatus;
+(function (MicrosoftTeamsChatTopicLookupStatus) {
+    MicrosoftTeamsChatTopicLookupStatus["Found"] = "Found";
+    MicrosoftTeamsChatTopicLookupStatus["NoTopic"] = "NoTopic";
+    MicrosoftTeamsChatTopicLookupStatus["PermissionDenied"] = "PermissionDenied";
+    MicrosoftTeamsChatTopicLookupStatus["Unknown"] = "Unknown";
+})(MicrosoftTeamsChatTopicLookupStatus || (MicrosoftTeamsChatTopicLookupStatus = {}));
+// How many Graph chat lookups Refresh Chats runs at once.
+const MICROSOFT_TEAMS_CHAT_TOPIC_LOOKUP_CONCURRENCY = 5;
+/*
+ * Per-lookup ceiling. Concurrent refreshes of a project share one run, so a
+ * lookup that never answers would otherwise hold every later Refresh Chats
+ * for that project.
+ */
+const MICROSOFT_TEAMS_CHAT_TOPIC_LOOKUP_TIMEOUT_IN_MS = 15000;
+/*
+ * Chat names are kept well under the 100-character ShortText columns that
+ * store them in notification logs — Teams chat names can be much longer.
+ */
+const MICROSOFT_TEAMS_CHAT_NAME_MAX_LENGTH = 80;
+// How many member names a group chat named after its members shows.
+const MICROSOFT_TEAMS_CHAT_NAME_MEMBERS_SHOWN = 3;
 /*
  * Microsoft's wording when the Bot Framework refuses a proactive post because
  * the app is not a member of the target conversation. Matched case-insensitively
@@ -90,6 +127,11 @@ const MICROSOFT_TEAMS_ROSTER_ERROR_FRAGMENTS = [
 ];
 // Maximum number of pages to fetch when paginating teams
 const MICROSOFT_TEAMS_MAX_PAGES = 500;
+// Bot commands that open a form; text after them becomes the form's title.
+const CREATE_INCIDENT_COMMAND = "create incident";
+const CREATE_MAINTENANCE_COMMAND = "create maintenance";
+// How many affected monitors a "show ..." reply names for one item.
+const MICROSOFT_TEAMS_MAX_AFFECTED_MONITOR_NAMES = 10;
 /*
  * Hosts that may receive a Teams incoming webhook. Legacy Connector webhooks
  * use Office domains. Teams Workflows use regional logic.azure.com hosts, and
@@ -1932,7 +1974,7 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
     }
     // Bot Framework specific methods
     static async handleBotMessageActivity(data) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         // Handle direct messages to bot or @mentions via Bot Framework
         const messageText = data.activity["text"] || "";
         const possibleActionValue = data.activity["value"] || {};
@@ -1991,18 +2033,8 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
                 onlyIfMissingOrStale: true,
             });
         }
-        // If this is actually an Adaptive Card submit wrapped as a message, route to invoke handler
-        if (possibleActionValue["action"] ||
-            ((_b = possibleActionValue["data"]) === null || _b === void 0 ? void 0 : _b["action"])) {
-            logger.debug("Message activity contains action payload; routing to invoke handler");
-            await this.handleBotInvokeActivity({
-                activity: data.activity,
-                turnContext: data.turnContext,
-            });
-            return;
-        }
         // Check if the bot was mentioned
-        const recipientId = (_c = data.activity["recipient"]) === null || _c === void 0 ? void 0 : _c["id"];
+        const recipientId = (_b = data.activity["recipient"]) === null || _b === void 0 ? void 0 : _b["id"];
         const conversationType = conversation["conversationType"] || "";
         const isDirectMessage = conversationType === "personal";
         const isMentioned = entities.some((entity) => {
@@ -2010,29 +2042,34 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
             return (entity["type"] === "mention" &&
                 ((_a = entity["mentioned"]) === null || _a === void 0 ? void 0 : _a["id"]) === recipientId);
         });
-        // Only respond if it's a direct message or the bot was mentioned
-        if (!isDirectMessage && !isMentioned) {
+        // An Adaptive Card submit arrives as a message whose value names the action.
+        const isCardSubmit = Boolean(possibleActionValue["action"] ||
+            ((_c = possibleActionValue["data"]) === null || _c === void 0 ? void 0 : _c["action"]));
+        // Only respond to card submits, direct messages and @mentions.
+        if (!isCardSubmit && !isDirectMessage && !isMentioned) {
             logger.debug("Bot not mentioned in channel message, ignoring");
             return;
         }
-        // Extract tenant ID to get project ID
-        const tenantId = (_d = channelData["tenant"]) === null || _d === void 0 ? void 0 : _d["id"];
-        if (!tenantId) {
-            logger.error("Tenant ID not found in channelData");
-            await data.turnContext.sendActivity("Sorry, I couldn't identify your organization. Please try again later.");
+        /*
+         * Teams delivers an activity again when the first delivery was slow or
+         * failed. Handling it twice sends every reply twice and creates a
+         * submitted incident twice, so only the first delivery is handled.
+         */
+        if (!(await MicrosoftTeamsActivityDeduplicator.claim(data.activity))) {
+            logger.debug("Microsoft Teams delivered this activity before; ignoring the repeat", {
+                activityId: data.activity["id"] || "",
+            });
             return;
         }
-        // Get project auth by tenant ID
-        const tenantResolution = await this.resolveProjectByTenantId({
-            tenantId: tenantId,
-        });
-        if (!tenantResolution.projectAuth ||
-            !tenantResolution.projectAuth.projectId) {
-            await data.turnContext.sendActivity(this.getTenantResolutionFailureMessage(tenantResolution));
+        // If this is actually an Adaptive Card submit wrapped as a message, route to invoke handler
+        if (isCardSubmit) {
+            logger.debug("Message activity contains action payload; routing to invoke handler");
+            await this.handleBotInvokeActivity({
+                activity: data.activity,
+                turnContext: data.turnContext,
+            });
             return;
         }
-        const projectId = tenantResolution.projectAuth.projectId;
-        logger.debug(`Found project ID: ${projectId.toString()} for tenant ID: ${tenantId}`);
         // Clean the message text by removing bot mentions
         const cleanText = messageText
             .replace(/<at[^>]*>.*?<\/at>/g, "")
@@ -2046,62 +2083,98 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
         const originalQuestionText = messageText
             .replace(/<at[^>]*>.*?<\/at>/g, "")
             .trim();
+        const isCreateIncidentCommand = cleanText === CREATE_INCIDENT_COMMAND ||
+            cleanText.startsWith(CREATE_INCIDENT_COMMAND + " ");
+        const isCreateMaintenanceCommand = cleanText === CREATE_MAINTENANCE_COMMAND ||
+            cleanText.startsWith(CREATE_MAINTENANCE_COMMAND + " ");
+        /*
+         * Explicit commands are matched precisely so that natural-language
+         * questions (which may incidentally contain words like "help" or
+         * "alerts") fall through to the AI assistant instead of a canned command.
+         */
+        const isHelpCommand = cleanText === "help" || cleanText === "" || cleanText === "?";
+        const isShowActiveIncidentsCommand = cleanText === "show active incidents" || cleanText === "active incidents";
+        const isShowScheduledMaintenanceCommand = cleanText === "show scheduled maintenance" ||
+            cleanText === "scheduled maintenance";
+        const isShowOngoingMaintenanceCommand = cleanText === "show ongoing maintenance" ||
+            cleanText === "ongoing maintenance";
+        const isShowActiveAlertsCommand = cleanText === "show active alerts" || cleanText === "active alerts";
+        /*
+         * "ask <question>" is an explicit prefix that always routes to the AI
+         * assistant. When present, strip the prefix and use the remainder as the
+         * question.
+         */
+        const isAskCommand = cleanText === "ask" || cleanText.startsWith("ask ");
+        /*
+         * The command, named for log lines that must not quote the message: a
+         * free-form question can carry things that do not belong in a log.
+         */
+        const commandName = (_d = [
+            { matches: isHelpCommand, name: "help" },
+            { matches: isCreateIncidentCommand, name: CREATE_INCIDENT_COMMAND },
+            { matches: isCreateMaintenanceCommand, name: CREATE_MAINTENANCE_COMMAND },
+            { matches: isShowActiveIncidentsCommand, name: "show active incidents" },
+            {
+                matches: isShowScheduledMaintenanceCommand,
+                name: "show scheduled maintenance",
+            },
+            {
+                matches: isShowOngoingMaintenanceCommand,
+                name: "show ongoing maintenance",
+            },
+            { matches: isShowActiveAlertsCommand, name: "show active alerts" },
+            { matches: isAskCommand, name: "ask" },
+        ].find((command) => {
+            return command.matches;
+        })) === null || _d === void 0 ? void 0 : _d.name;
+        let projectId = undefined;
         let responseText = "";
         try {
-            const isCreateIncidentCommand = cleanText === "create incident" ||
-                cleanText.startsWith("create incident ");
-            const isCreateMaintenanceCommand = cleanText === "create maintenance" ||
-                cleanText.startsWith("create maintenance ");
-            /*
-             * Explicit commands are matched precisely so that natural-language
-             * questions (which may incidentally contain words like "help" or
-             * "alerts") fall through to the AI assistant instead of a canned command.
-             */
-            const isHelpCommand = cleanText === "help" || cleanText === "" || cleanText === "?";
-            const isShowActiveIncidentsCommand = cleanText === "show active incidents" ||
-                cleanText === "active incidents";
-            const isShowScheduledMaintenanceCommand = cleanText === "show scheduled maintenance" ||
-                cleanText === "scheduled maintenance";
-            const isShowOngoingMaintenanceCommand = cleanText === "show ongoing maintenance" ||
-                cleanText === "ongoing maintenance";
-            const isShowActiveAlertsCommand = cleanText === "show active alerts" || cleanText === "active alerts";
-            /*
-             * "ask <question>" is an explicit prefix that always routes to the AI
-             * assistant. When present, strip the prefix and use the remainder as the
-             * question.
-             */
-            const isAskCommand = cleanText === "ask" || cleanText.startsWith("ask ");
+            // Extract tenant ID to get project ID
+            const tenantId = (_e = channelData["tenant"]) === null || _e === void 0 ? void 0 : _e["id"];
+            if (!tenantId) {
+                logger.error("Tenant ID not found in channelData");
+                await data.turnContext.sendActivity("Sorry, I couldn't identify your organization. Please try again later.");
+                return;
+            }
+            // Get project auth by tenant ID
+            const tenantResolution = await this.resolveProjectByTenantId({
+                tenantId: tenantId,
+            });
+            if (!tenantResolution.projectAuth ||
+                !tenantResolution.projectAuth.projectId) {
+                await data.turnContext.sendActivity(this.getTenantResolutionFailureMessage(tenantResolution));
+                return;
+            }
+            projectId = tenantResolution.projectAuth.projectId;
+            logger.debug(`Found project ID: ${projectId.toString()} for tenant ID: ${tenantId}`);
             if (isHelpCommand) {
                 responseText = this.getHelpMessage();
             }
             else if (isCreateIncidentCommand) {
-                // Handle create incident command (legacy slash command supported)
+                // "create incident <title>" opens the form with the title filled in.
                 logger.debug("Processing create incident command");
-                const card = await MicrosoftTeamsIncidentActions.buildNewIncidentCard(projectId);
-                await data.turnContext.sendActivity({
-                    attachments: [
-                        {
-                            contentType: "application/vnd.microsoft.card.adaptive",
-                            content: card,
-                        },
-                    ],
+                await MicrosoftTeamsCreateCommands.handleCreateIncidentCommand({
+                    turnContext: data.turnContext,
+                    activity: data.activity,
+                    projectId: projectId,
+                    initialTitle: originalQuestionText
+                        .substring(CREATE_INCIDENT_COMMAND.length)
+                        .trim(),
                 });
-                logger.debug("New incident card sent successfully");
                 return;
             }
             else if (isCreateMaintenanceCommand) {
-                // Handle create maintenance command (legacy slash command supported)
+                // "create maintenance <title>" opens the form with the title filled in.
                 logger.debug("Processing create maintenance command");
-                const card = await MicrosoftTeamsScheduledMaintenanceActions.buildNewScheduledMaintenanceCard(projectId);
-                await data.turnContext.sendActivity({
-                    attachments: [
-                        {
-                            contentType: "application/vnd.microsoft.card.adaptive",
-                            content: card,
-                        },
-                    ],
+                await MicrosoftTeamsCreateCommands.handleCreateScheduledMaintenanceCommand({
+                    turnContext: data.turnContext,
+                    activity: data.activity,
+                    projectId: projectId,
+                    initialTitle: originalQuestionText
+                        .substring(CREATE_MAINTENANCE_COMMAND.length)
+                        .trim(),
                 });
-                logger.debug("New scheduled maintenance card sent successfully");
                 return;
             }
             else if (isShowActiveIncidentsCommand) {
@@ -2139,18 +2212,71 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
                 });
                 return;
             }
-            // Send response directly using TurnContext - this is the recommended Bot Framework pattern
-            await data.turnContext.sendActivity(responseText);
+            /*
+             * Send response directly using TurnContext - this is the recommended Bot
+             * Framework pattern. Lists grow with the project, so the text is kept
+             * within what Teams accepts.
+             */
+            await data.turnContext.sendActivity(MicrosoftTeamsMessageSize.fitTextToBudget({ text: responseText }));
             logger.debug("Bot message sent successfully using TurnContext", {
                 projectId: projectId.toString(),
             });
         }
         catch (error) {
-            logger.error("Error sending bot message via TurnContext: " + error, {
-                projectId: projectId.toString(),
+            /*
+             * One reply, and no rethrow. This used to reply and then rethrow: the
+             * adapter answered Teams with HTTP 500, Teams delivered the message
+             * again, and every failure showed up twice (issue #4111).
+             */
+            /*
+             * The command is named, not quoted: a free-form question can carry
+             * things that do not belong in an error log. The text is in the debug
+             * log above.
+             */
+            MicrosoftTeamsReplies.logFailure(`Microsoft Teams message ${data.activity["id"] || ""} (${commandName
+                ? `"${commandName}"`
+                : `a ${cleanText.length}-character question`}) failed`, error, {
+                projectId: projectId === null || projectId === void 0 ? void 0 : projectId.toString(),
+            });
+            await MicrosoftTeamsReplies.sendBestEffort(data.turnContext, this.getUnexpectedErrorMessage(data.activity));
+        }
+    }
+    /*
+     * The reply to a message whose handling failed in a way nobody planned for.
+     * It names the activity id, which the server log line carries too, so an
+     * administrator can find what went wrong.
+     */
+    static getUnexpectedErrorMessage(activity) {
+        const reference = activity["id"] || "";
+        return `Sorry, something went wrong in OneUptime while handling that message. Please try again in a minute.${reference
+            ? ` If it keeps happening, ask your OneUptime administrator to look for reference ${reference} in the server logs.`
+            : ""}`;
+    }
+    /*
+     * The last line of defence for an inbound activity whose handler threw.
+     *
+     * The error is logged and the turn ends normally, so CloudAdapter answers
+     * Teams with 200. Letting the error through made CloudAdapter answer HTTP
+     * 500, Teams delivered the activity again, and every reply the turn had
+     * posted appeared twice (issue #4111). A message that got no reply yet gets
+     * one; an invoke gets the response it needs, or CloudAdapter answers 501.
+     *
+     * This is deliberately not adapter.onTurnError: the same adapter sends
+     * proactive notifications, and their callers need their errors thrown.
+     */
+    static async recoverFromFailedTurn(data) {
+        const { turnContext, error } = data;
+        const activity = turnContext.activity || {};
+        MicrosoftTeamsReplies.logFailure(`Microsoft Teams ${activity.type || "unknown"} activity ${activity.id || ""} failed`, error);
+        if (activity.type === "message" && !turnContext.responded) {
+            await MicrosoftTeamsReplies.sendBestEffort(turnContext, this.getUnexpectedErrorMessage(activity));
+            return;
+        }
+        if (activity.type === "invoke") {
+            await MicrosoftTeamsReplies.sendBestEffort(turnContext, {
+                type: "invokeResponse",
+                value: { status: 200 },
             });
-            await data.turnContext.sendActivity("Sorry, I encountered an error processing your request. Please try again later.");
-            throw error;
         }
     }
     /*
@@ -2159,13 +2285,31 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
      * channel/chat message bodies are typically HTML (body.contentType "html").
      */
     static toPlainTextFromTeamsMessageBody(rawContent) {
-        return rawContent
-            .replace(/<at[^>]*>.*?<\/at>/g, "")
-            .replace(/<[^>]*>/g, "")
+        return this.stripHtmlTags(rawContent.replace(/<at[^>]*>.*?<\/at>/g, ""))
             .replace(/&nbsp;/g, " ")
             .replace(/\s+/g, " ")
             .trim();
     }
+    /*
+     * Plain text out of a Teams message body, which Graph and the Bot Framework
+     * hand over as HTML. Removing complete tags is not enough on its own: an
+     * unclosed one ("<script" with no ">" after it) matches no tag pattern, so
+     * once no tag is left, any "<" still standing goes too, and the text holds
+     * no markup at all. The tag pass repeats until nothing changes - the shape
+     * code scanning recognises as complete, where a single pass is reported as
+     * incomplete multi-character sanitization. Teams sends a literal "<" in a
+     * message as "&lt;", which is left encoded: decoding it here would hand
+     * back what this removed.
+     */
+    static stripHtmlTags(html) {
+        let text = html;
+        let previous;
+        do {
+            previous = text;
+            text = text.replace(/<[^>]*>/g, "");
+        } while (text !== previous);
+        return text.replace(/</g, "");
+    }
     /*
      * AI Ops: gather the prior turns of the current Teams conversation/thread and
      * map them to the assistant's history shape ({ role, content }, oldest-first,
@@ -2349,12 +2493,18 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
                 });
         }
         catch (error) {
+            // A failed lookup is not a missing account; the caller answers it.
+            if (!(error instanceof MicrosoftTeamsAccountNotLinkedException)) {
+                throw error;
+            }
             logger.debug("No OneUptime user linked to Teams user; prompting to connect account", {
                 projectId: projectId.toString(),
                 workspaceUserId: teamsUserId,
             });
-            logger.debug(error);
-            await turnContext.sendActivity("I couldn't find your OneUptime account. Please connect your Microsoft Teams account in OneUptime User Settings before asking me questions.");
+            await turnContext.sendActivity(await MicrosoftTeamsReplies.getAccountNotLinkedMessage({
+                projectId: projectId,
+                purpose: "ask OneUptime questions from Microsoft Teams",
+            }));
             return;
         }
         // The user's real permission props - the assistant's tools run under these.
@@ -2455,6 +2605,25 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
             await turnContext.sendActivity("Sorry, I ran into a problem answering that question. Please try again later.");
         }
     }
+    /*
+     * The monitors an incident or maintenance event affects, as one line: the
+     * first few names, then how many more. An event can cover hundreds of
+     * monitors, and listing them all made the reply too large for Teams.
+     */
+    static formatAffectedMonitorNames(monitors) {
+        const names = monitors
+            .map((monitor) => {
+            return monitor.name || "";
+        })
+            .filter((name) => {
+            return Boolean(name);
+        });
+        const shownNames = names.slice(0, MICROSOFT_TEAMS_MAX_AFFECTED_MONITOR_NAMES);
+        const notShownCount = names.length - shownNames.length;
+        return notShownCount > 0
+            ? `${shownNames.join(", ")} and ${notShownCount} more`
+            : shownNames.join(", ");
+    }
     // Helper methods for bot commands
     static getHelpMessage() {
         return `Hello! I'm the OneUptime bot. I can help you with the following commands:
@@ -2462,8 +2631,8 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
 **Available Commands:**
 - **help** - Show this help message
 - **ask <question>** - Ask OneUptime AI about your logs, traces, metrics, incidents and monitors
-- **create incident** - Create a new incident
-- **create maintenance** - Create a new scheduled maintenance event
+- **create incident [title]** - Create a new incident
+- **create maintenance [title]** - Create a new scheduled maintenance event
 - **show active incidents** - Display all currently active incidents
 - **show scheduled maintenance** - Show upcoming scheduled maintenance events
 - **show ongoing maintenance** - Display currently ongoing maintenance events
@@ -2547,11 +2716,7 @@ If you need to report an incident or check historical incidents, please visit th
 • **Declared:** ${declaredAtText}
 `;
                 if (incident.monitors && incident.monitors.length > 0) {
-                    message += `• **Affected Services:** ${incident.monitors
-                        .map((m) => {
-                        return m.name;
-                    })
-                        .join(", ")}\n`;
+                    message += `• **Affected Services:** ${this.formatAffectedMonitorNames(incident.monitors)}\n`;
                 }
                 if (incident.description) {
                     const desc = incident.description.replace(/\s+/g, " ");
@@ -2635,11 +2800,7 @@ Check back later for upcoming maintenance windows.`;
 • **Ends:** ${endTime}
 `;
                 if (event.monitors && event.monitors.length > 0) {
-                    message += `• **Affected Services:** ${event.monitors
-                        .map((m) => {
-                        return m.name;
-                    })
-                        .join(", ")}\n`;
+                    message += `• **Affected Services:** ${this.formatAffectedMonitorNames(event.monitors)}\n`;
                 }
                 if (event.description) {
                     const desc = event.description.replace(/\s+/g, " ");
@@ -2722,11 +2883,7 @@ All systems are currently operating normally.`;
 • **Expected End:** ${endTime}
 `;
                 if (event.monitors && event.monitors.length > 0) {
-                    message += `• **Affected Services:** ${event.monitors
-                        .map((m) => {
-                        return m.name;
-                    })
-                        .join(", ")}\n`;
+                    message += `• **Affected Services:** ${this.formatAffectedMonitorNames(event.monitors)}\n`;
                 }
                 if (event.description) {
                     const desc = event.description.replace(/\s+/g, " ");
@@ -2838,6 +2995,7 @@ All monitoring checks are passing normally.`;
         const { actionType, actionValue } = this.extractActionFromValue(value);
         logger.debug(`Bot invoke activity - Action type: ${actionType}`);
         logger.debug(`Bot invoke value: ${JSON.stringify(value)}`);
+        let projectId = undefined;
         try {
             // Resolve project and user context from activity
             const channelData = data.activity["channelData"] || {};
@@ -2855,7 +3013,7 @@ All monitoring checks are passing normally.`;
                 await data.turnContext.sendActivity(this.getTenantResolutionFailureMessage(tenantResolution));
                 return;
             }
-            const projectId = tenantResolution.projectAuth.projectId;
+            projectId = tenantResolution.projectAuth.projectId;
             const fromObj = (data.activity["from"] ||
                 {});
             const teamsUserId = fromObj["aadObjectId"] || undefined;
@@ -2968,19 +3126,39 @@ All monitoring checks are passing normally.`;
             }
         }
         catch (error) {
+            /*
+             * Every reply below is sent best-effort: a reply that fails here must
+             * not escape, or the adapter answers Teams with HTTP 500 and Teams
+             * delivers the action again (issue #4111).
+             */
+            // The account is not connected: say where to connect it.
+            if (error instanceof MicrosoftTeamsAccountNotLinkedException &&
+                projectId) {
+                logger.debug("Bot invoke activity from a Teams user with no linked account", {
+                    actionType: actionType,
+                });
+                await MicrosoftTeamsReplies.sendBestEffort(data.turnContext, await MicrosoftTeamsReplies.getAccountNotLinkedMessage({
+                    projectId: projectId,
+                    purpose: "use OneUptime actions in Microsoft Teams",
+                }));
+                return;
+            }
             // Tell the user why they were refused; the message is written for them.
             if (error instanceof NotAuthorizedException) {
                 logger.debug("Bot invoke activity refused: " + error.message, {
                     actionType: actionType,
                 });
-                await data.turnContext.sendActivity(error.message);
+                await MicrosoftTeamsReplies.sendBestEffort(data.turnContext, error.message);
                 return;
             }
-            logger.error("Error handling bot invoke activity:", {
+            MicrosoftTeamsReplies.logFailure("Error handling bot invoke activity", error, {
                 actionType: actionType,
+                projectId: projectId === null || projectId === void 0 ? void 0 : projectId.toString(),
             });
-            logger.error(error);
-            await data.turnContext.sendActivity("Sorry, that action failed. Please try again later.");
+            const reason = MicrosoftTeamsReplies.getUserFacingErrorMessage(error);
+            await MicrosoftTeamsReplies.sendBestEffort(data.turnContext, reason
+                ? `Sorry, that action failed: ${reason}`
+                : "Sorry, that action failed. Please try again later.");
         }
     }
     static async handleConversationUpdateActivity(data) {
@@ -3167,36 +3345,117 @@ All monitoring checks are passing normally.`;
         return null; // channels and meetings are not chats.
     }
     static getChatDisplayName(data) {
-        /*
-         * Keep well under the 100-char ShortText columns that store the chat
-         * name in notification logs — Teams chat topics can be much longer.
-         */
-        const maxNameLength = 80;
         const truncate = (name) => {
-            return name.length > maxNameLength
-                ? `${name.substring(0, maxNameLength - 1)}…`
-                : name;
+            if (name.length <= MICROSOFT_TEAMS_CHAT_NAME_MAX_LENGTH) {
+                return name;
+            }
+            /*
+             * Cut by UTF-16 code units, but never between the two halves of an
+             * emoji: a lone surrogate makes Postgres refuse the whole jsonb write
+             * that carries the name.
+             */
+            return `${truncateToLength(name, MICROSOFT_TEAMS_CHAT_NAME_MAX_LENGTH - 1)}…`;
         };
         if (data.topic && data.topic.trim()) {
             return truncate(data.topic.trim());
         }
-        const memberNames = data.memberNames.filter((name) => {
-            return Boolean(name && name.trim());
-        });
+        const memberNames = this.getNonBlankNames(data.memberNames);
         if (data.chatType === "personal") {
             return memberNames[0] ? truncate(`${memberNames[0]}`) : "Personal chat";
         }
         if (memberNames.length === 0) {
             return "Group chat";
         }
-        const maxNamesToShow = 3;
-        const shownNames = memberNames.slice(0, maxNamesToShow);
-        const remainingCount = memberNames.length - shownNames.length;
+        const shownNames = memberNames.slice(0, MICROSOFT_TEAMS_CHAT_NAME_MEMBERS_SHOWN);
+        const memberCount = Math.max(data.memberCount || 0, memberNames.length);
+        const remainingCount = memberCount - shownNames.length;
         if (remainingCount > 0) {
             return truncate(`${shownNames.join(", ")} + ${remainingCount} more`);
         }
         return truncate(shownNames.join(", "));
     }
+    static getNonBlankNames(names) {
+        return names.filter((name) => {
+            return Boolean(name && name.trim());
+        });
+    }
+    /*
+     * Builds the record to store for a chat that was just heard from, on top of
+     * what is already stored. Whatever could not be read this time — the name
+     * (Graph refused, failed, or was not asked) or the roster (the Bot Framework
+     * call failed) — is taken from the stored record instead of being dropped:
+     * a failed lookup must never turn a chat's real name back into member
+     * names, or member names into a bare "Group chat".
+     */
+    static buildCapturedChat(data) {
+        var _a, _b, _c;
+        const storedChat = data.storedChat;
+        const activityTopic = (data.activityTopic || "").trim();
+        const lookupStatus = (_a = data.topicLookup) === null || _a === void 0 ? void 0 : _a.status;
+        const topicCleared = !activityTopic &&
+            lookupStatus === MicrosoftTeamsChatTopicLookupStatus.NoTopic;
+        let topic = undefined;
+        if (activityTopic) {
+            topic = activityTopic;
+        }
+        else if (lookupStatus === MicrosoftTeamsChatTopicLookupStatus.Found) {
+            topic = (_b = data.topicLookup) === null || _b === void 0 ? void 0 : _b.topic;
+        }
+        else if (!topicCleared) {
+            topic = storedChat === null || storedChat === void 0 ? void 0 : storedChat.topic; // not read this time: keep the last known name.
+        }
+        let memberNames = (_c = storedChat === null || storedChat === void 0 ? void 0 : storedChat.memberNames) === null || _c === void 0 ? void 0 : _c.slice(0, MICROSOFT_TEAMS_CHAT_NAME_MEMBERS_SHOWN);
+        let memberCount = storedChat === null || storedChat === void 0 ? void 0 : storedChat.memberCount;
+        let memberAadObjectIds = (storedChat === null || storedChat === void 0 ? void 0 : storedChat.memberAadObjectIds) || [];
+        if (data.roster) {
+            const names = this.getNonBlankNames(data.roster.memberNames);
+            memberNames = names.slice(0, MICROSOFT_TEAMS_CHAT_NAME_MEMBERS_SHOWN);
+            memberCount = names.length;
+            memberAadObjectIds = data.roster.memberAadObjectIds;
+        }
+        let name;
+        if (topic || (memberNames && memberNames.length > 0)) {
+            name = this.getChatDisplayName({
+                chatType: data.chatType,
+                topic: topic,
+                memberNames: memberNames || [],
+                memberCount: memberCount,
+            });
+        }
+        else if ((storedChat === null || storedChat === void 0 ? void 0 : storedChat.name) && !(topicCleared && storedChat.topic)) {
+            /*
+             * Nothing to build a name from this time. The stored name is still the
+             * best there is — unless it was the Teams name, and Teams just said the
+             * chat no longer has one.
+             */
+            name = storedChat.name;
+        }
+        else {
+            name = this.getChatDisplayName({
+                chatType: data.chatType,
+                memberNames: [],
+            });
+        }
+        const chat = {
+            id: data.chatId,
+            name: name,
+            chatType: data.chatType,
+            serviceUrl: data.serviceUrl,
+            // When the chat was first connected; hearing from it again is not that.
+            addedAt: (storedChat === null || storedChat === void 0 ? void 0 : storedChat.addedAt) || data.now,
+            memberAadObjectIds: memberAadObjectIds,
+        };
+        if (topic) {
+            chat.topic = topic;
+        }
+        if (memberNames !== undefined) {
+            chat.memberNames = memberNames;
+        }
+        if (memberCount !== undefined) {
+            chat.memberCount = memberCount;
+        }
+        return chat;
+    }
     /*
      * Returns true when every connected project of this tenant already has
      * this chat stored with the same service URL — i.e. there is nothing to
@@ -3239,6 +3498,20 @@ All monitoring checks are passing normally.`;
                 (chat.memberAadObjectIds || []).length === 0) {
                 return false;
             }
+            /*
+             * Group chats captured before member counts were stored were also
+             * captured before OneUptime asked Graph for their name. Re-capture
+             * them once: that stores the roster (so the name can fall back to the
+             * members if the chat's name is ever removed), and reads the name if
+             * the chat already lets OneUptime read it. Chats the app was added to
+             * with an older manifest only allow that once the app is updated in the
+             * chat, which sends no activity — Refresh Chats picks the name up then.
+             * A roster that could not be read leaves the count unset, so the next
+             * message tries again.
+             */
+            if (chat.chatType === "groupChat" && chat.memberCount === undefined) {
+                return false;
+            }
         }
         return true;
     }
@@ -3281,9 +3554,11 @@ All monitoring checks are passing normally.`;
                 }
             }
             // Resolve a human friendly name for the chat.
-            const topic = conversation["name"];
-            let memberNames = [];
-            let memberAadObjectIds = [];
+            const activityTopic = typeof conversation["name"] === "string"
+                ? conversation["name"].trim()
+                : "";
+            // null when the roster could not be read.
+            let roster = null;
             try {
                 const botId = (_b = data.turnContext.activity.recipient) === null || _b === void 0 ? void 0 : _b.id;
                 /*
@@ -3300,38 +3575,54 @@ All monitoring checks are passing normally.`;
                 const humanMembers = members.filter((member) => {
                     return member.id !== botId;
                 });
-                memberNames = humanMembers.map((member) => {
-                    return member.name || "";
-                });
-                /*
-                 * The Entra object id is what maps a chat member back to the
-                 * OneUptime user who connected that Teams account, so personal chats
-                 * can serve as direct-message delivery targets.
-                 */
-                memberAadObjectIds = humanMembers
-                    .map((member) => {
-                    return member.aadObjectId || "";
-                })
-                    .filter((aadObjectId) => {
-                    return Boolean(aadObjectId);
-                });
+                roster = {
+                    memberNames: humanMembers.map((member) => {
+                        return member.name || "";
+                    }),
+                    /*
+                     * The Entra object id is what maps a chat member back to the
+                     * OneUptime user who connected that Teams account, so personal
+                     * chats can serve as direct-message delivery targets.
+                     */
+                    memberAadObjectIds: humanMembers
+                        .map((member) => {
+                        return member.aadObjectId || "";
+                    })
+                        .filter((aadObjectId) => {
+                        return Boolean(aadObjectId);
+                    }),
+                };
             }
             catch (err) {
                 logger.debug("Could not fetch chat members for chat name resolution");
                 logger.debug(err);
             }
-            const chat = {
-                id: chatId,
-                name: this.getChatDisplayName({
-                    chatType: chatType,
-                    topic: topic,
-                    memberNames: memberNames,
-                }),
+            const tenantChat = await this.getTenantChatContext({
+                tenantId: tenantId,
+                chatId: chatId,
+            });
+            /*
+             * Teams does not reliably put a group chat's name on its activities, so
+             * a named group chat would otherwise be listed by its members. Graph has
+             * the name; ask it. Personal chats have no name to find.
+             */
+            let topicLookup = undefined;
+            if (chatType === "groupChat" && !activityTopic && tenantChat.projectId) {
+                topicLookup = await this.getGroupChatTopicFromGraph({
+                    projectId: tenantChat.projectId,
+                    chatId: chatId,
+                });
+            }
+            const chat = this.buildCapturedChat({
+                chatId: chatId,
                 chatType: chatType,
                 serviceUrl: activityServiceUrl,
-                addedAt: OneUptimeDate.getCurrentDate().toISOString(),
-                memberAadObjectIds: memberAadObjectIds,
-            };
+                activityTopic: activityTopic,
+                topicLookup: topicLookup,
+                roster: roster,
+                storedChat: tenantChat.storedChat,
+                now: OneUptimeDate.getCurrentDate().toISOString(),
+            });
             await this.saveChatToProjectAuthTokens({
                 tenantId: tenantId,
                 chat: chat,
@@ -3440,6 +3731,303 @@ All monitoring checks are passing normally.`;
             });
         }
     }
+    /*
+     * What a bot activity needs to know about its tenant before storing a chat:
+     * any project connected to the tenant (bot activities identify the tenant,
+     * not the project, and every project of a tenant yields the same Graph app
+     * token), and the chat as it is stored now, so a re-capture builds on it.
+     *
+     * A failed read throws: capturing without knowing what is stored would
+     * overwrite a chat's real name with whatever this activity could supply.
+     */
+    static async getTenantChatContext(data) {
+        var _a, _b;
+        let projectId = null;
+        let storedChat = undefined;
+        const projectAuths = await WorkspaceProjectAuthTokenService.findBy({
+            query: {
+                workspaceType: WorkspaceType.MicrosoftTeams,
+                workspaceProjectId: data.tenantId,
+            },
+            select: {
+                _id: true,
+                projectId: true,
+                miscData: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        for (const projectAuth of projectAuths) {
+            if (!projectId && projectAuth.projectId) {
+                projectId = projectAuth.projectId;
+            }
+            if (!storedChat) {
+                storedChat = (_b = (_a = projectAuth.miscData) === null || _a === void 0 ? void 0 : _a.availableChats) === null || _b === void 0 ? void 0 : _b[data.chatId];
+            }
+        }
+        return { projectId: projectId, storedChat: storedChat };
+    }
+    /*
+     * Reads a group chat's name from Graph (GET /chats/{id}). Only group chats
+     * are looked up: their Bot Framework conversation id is also their Graph
+     * chat id, and they are the only chats that can be named.
+     *
+     * Never throws. A refusal comes back as PermissionDenied — the app-only
+     * token needs ChatSettings.Read.Chat (granted per chat, and chats the app
+     * was added to before the manifest requested it do not have it) or the
+     * tenant-wide Chat.ReadBasic.WhereInstalled. Pass accessToken when looking
+     * up many chats, so the token is fetched once rather than once per chat.
+     */
+    static async getGroupChatTopicFromGraph(data) {
+        var _a;
+        if (!data.chatId) {
+            return { status: MicrosoftTeamsChatTopicLookupStatus.Unknown };
+        }
+        try {
+            const accessToken = data.accessToken ||
+                (await this.getValidAccessToken({
+                    authToken: "",
+                    projectId: data.projectId,
+                }));
+            const response = await API.get({
+                url: URL.fromString(`https://graph.microsoft.com/v1.0/chats/${encodeURIComponent(data.chatId)}`),
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                    "Content-Type": "application/json",
+                },
+                options: {
+                    timeout: MICROSOFT_TEAMS_CHAT_TOPIC_LOOKUP_TIMEOUT_IN_MS,
+                },
+            });
+            if (response instanceof HTTPErrorResponse) {
+                if (this.isGraphPermissionDeniedResponse(response)) {
+                    logger.debug(`Cannot read the name of Microsoft Teams chat ${data.chatId}: Microsoft Graph denied the request. The OneUptime app in that chat needs the ${MICROSOFT_TEAMS_CHAT_TOPIC_READ_PERMISSION} permission — update the app in the chat so Teams grants it.`);
+                    return {
+                        status: MicrosoftTeamsChatTopicLookupStatus.PermissionDenied,
+                    };
+                }
+                /*
+                 * A 404 for a chat the bot is in would mean the Bot Framework
+                 * conversation id is not the Graph chat id — worth seeing in
+                 * production logs, unlike a passing throttle or outage.
+                 */
+                if (response.statusCode === 404) {
+                    logger.warn(`Microsoft Graph has no chat with the id of Microsoft Teams chat ${data.chatId}, so its name cannot be read.`);
+                }
+                else {
+                    logger.debug(`Could not read Microsoft Teams chat ${data.chatId}:`);
+                    logger.debug(response);
+                }
+                return { status: MicrosoftTeamsChatTopicLookupStatus.Unknown };
+            }
+            const topic = (_a = response.data) === null || _a === void 0 ? void 0 : _a["topic"];
+            if (typeof topic === "string" && topic.trim()) {
+                return {
+                    status: MicrosoftTeamsChatTopicLookupStatus.Found,
+                    topic: topic.trim(),
+                };
+            }
+            return { status: MicrosoftTeamsChatTopicLookupStatus.NoTopic };
+        }
+        catch (err) {
+            logger.debug(`Error reading Microsoft Teams chat ${data.chatId}:`);
+            logger.debug(err);
+            return { status: MicrosoftTeamsChatTopicLookupStatus.Unknown };
+        }
+    }
+    /*
+     * What "Refresh Chats" does. Microsoft does not let an app list chats, but
+     * it does let it read one it is in — so every stored group chat is re-read,
+     * which fixes chats captured under their member names and picks up renames.
+     *
+     * A chat whose name was removed in Teams goes back to its member names when
+     * they were stored with it; otherwise it keeps its current name, unless
+     * that was the removed Teams name. A chat whose name could not be read is
+     * left as it is and reported, so the page can say why.
+     *
+     * Concurrent refreshes of one project (within this App process) share a
+     * single run, so a held-down button costs one pass over the chats, not one
+     * per click.
+     */
+    static async refreshChatNamesForProject(data) {
+        const key = data.projectId.toString();
+        const inFlight = this.chatNameRefreshesInFlight.get(key);
+        if (inFlight) {
+            return inFlight;
+        }
+        const refresh = this.runChatNameRefresh(data).finally(() => {
+            this.chatNameRefreshesInFlight.delete(key);
+        });
+        this.chatNameRefreshesInFlight.set(key, refresh);
+        return refresh;
+    }
+    static async runChatNameRefresh(data) {
+        var _a;
+        const projectAuth = await WorkspaceProjectAuthTokenService.getProjectAuth({
+            projectId: data.projectId,
+            workspaceType: WorkspaceType.MicrosoftTeams,
+        });
+        const storedChats = ((_a = projectAuth === null || projectAuth === void 0 ? void 0 : projectAuth.miscData) === null || _a === void 0 ? void 0 : _a.availableChats) || {};
+        const result = {
+            chats: Object.assign({}, storedChats),
+            permissionDeniedChatIds: [],
+            failedChatIds: [],
+        };
+        const tenantId = projectAuth === null || projectAuth === void 0 ? void 0 : projectAuth.workspaceProjectId;
+        const groupChats = Object.values(storedChats).filter((chat) => {
+            return Boolean(chat && chat.id && chat.chatType === "groupChat");
+        });
+        if (!tenantId || groupChats.length === 0) {
+            return result;
+        }
+        /*
+         * One token for every lookup. Without one nothing can be read, and that
+         * is a failure the caller must see — not a refresh that silently changed
+         * nothing.
+         */
+        const accessToken = await this.getValidAccessToken({
+            authToken: "",
+            projectId: data.projectId,
+        });
+        const updates = {};
+        for (let index = 0; index < groupChats.length; index += MICROSOFT_TEAMS_CHAT_TOPIC_LOOKUP_CONCURRENCY) {
+            const batch = groupChats.slice(index, index + MICROSOFT_TEAMS_CHAT_TOPIC_LOOKUP_CONCURRENCY);
+            const lookups = await Promise.all(batch.map((chat) => {
+                return this.getGroupChatTopicFromGraph({
+                    projectId: data.projectId,
+                    chatId: chat.id,
+                    accessToken: accessToken,
+                });
+            }));
+            batch.forEach((chat, batchIndex) => {
+                const lookup = lookups[batchIndex];
+                if (lookup.status === MicrosoftTeamsChatTopicLookupStatus.PermissionDenied) {
+                    result.permissionDeniedChatIds.push(chat.id);
+                    return;
+                }
+                if (lookup.status === MicrosoftTeamsChatTopicLookupStatus.Unknown) {
+                    result.failedChatIds.push(chat.id);
+                    return;
+                }
+                const update = this.getChatNameUpdate({
+                    chat: chat,
+                    lookup: lookup,
+                });
+                if (update.name !== chat.name || update.topic !== chat.topic) {
+                    updates[chat.id] = update;
+                }
+            });
+        }
+        if (Object.keys(updates).length > 0) {
+            await this.renameChatsInProjectAuthTokens({
+                tenantId: tenantId,
+                chatNames: updates,
+            });
+        }
+        /*
+         * What is stored now, whether or not anything was renamed: a chat
+         * removed while names were being read is gone, and is not reported.
+         */
+        result.chats = await this.getChatsForProject({
+            projectId: data.projectId,
+        });
+        return result;
+    }
+    // The name a stored group chat gets from a lookup that Graph answered.
+    static getChatNameUpdate(data) {
+        const chat = data.chat;
+        if (data.lookup.status === MicrosoftTeamsChatTopicLookupStatus.Found &&
+            data.lookup.topic) {
+            return {
+                name: this.getChatDisplayName({
+                    chatType: chat.chatType,
+                    topic: data.lookup.topic,
+                    memberNames: [],
+                }),
+                topic: data.lookup.topic,
+            };
+        }
+        // The chat has no name in Teams.
+        if (chat.memberNames && chat.memberNames.length > 0) {
+            return {
+                name: this.getChatDisplayName({
+                    chatType: chat.chatType,
+                    memberNames: chat.memberNames,
+                    memberCount: chat.memberCount,
+                }),
+            };
+        }
+        /*
+         * No members to name it after. Keep the current name — unless it was the
+         * Teams name that has just been removed.
+         */
+        return {
+            name: chat.topic
+                ? this.getChatDisplayName({ chatType: chat.chatType, memberNames: [] })
+                : chat.name,
+        };
+    }
+    /*
+     * Sets the name (and the Teams name it came from) of chats already stored
+     * for a tenant, on every connected project. Only those fields are written,
+     * onto each record as it is now — a chat removed or re-captured while names
+     * were being looked up is neither resurrected nor rolled back.
+     */
+    static async renameChatsInProjectAuthTokens(data) {
+        const projectAuths = await WorkspaceProjectAuthTokenService.findBy({
+            query: {
+                workspaceType: WorkspaceType.MicrosoftTeams,
+                workspaceProjectId: data.tenantId,
+            },
+            select: {
+                _id: true,
+                miscData: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        for (const projectAuth of projectAuths) {
+            const miscData = Object.assign({}, (projectAuth.miscData || {}));
+            const availableChats = Object.assign({}, (miscData.availableChats || {}));
+            let changed = false;
+            for (const [chatId, update] of Object.entries(data.chatNames)) {
+                const existingChat = availableChats[chatId];
+                if (!existingChat ||
+                    (existingChat.name === update.name &&
+                        existingChat.topic === update.topic)) {
+                    continue;
+                }
+                const renamedChat = Object.assign(Object.assign({}, existingChat), { name: update.name });
+                if (update.topic) {
+                    renamedChat.topic = update.topic;
+                }
+                else {
+                    delete renamedChat.topic;
+                }
+                availableChats[chatId] = renamedChat;
+                changed = true;
+            }
+            if (!changed) {
+                continue;
+            }
+            miscData.availableChats = availableChats;
+            await WorkspaceProjectAuthTokenService.updateOneById({
+                id: projectAuth.id,
+                data: {
+                    miscData: miscData,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+        }
+    }
     static async getChatsForProject(data) {
         const projectAuth = await WorkspaceProjectAuthTokenService.getProjectAuth({
             projectId: data.projectId,
@@ -3865,8 +4453,17 @@ All monitoring checks are passing normally.`;
                         from: (_a = context.activity.from) === null || _a === void 0 ? void 0 : _a.name,
                         conversationId: (_b = context.activity.conversation) === null || _b === void 0 ? void 0 : _b.id,
                     }));
-                // Run the activity through our activity handler
-                await activityHandler.run(context);
+                try {
+                    // Run the activity through our activity handler
+                    await activityHandler.run(context);
+                }
+                catch (error) {
+                    // Never answer Teams with a 500; see recoverFromFailedTurn.
+                    await MicrosoftTeamsUtil.recoverFromFailedTurn({
+                        turnContext: context,
+                        error: error,
+                    });
+                }
             });
             logger.debug("Bot Framework activity processed successfully");
         }
@@ -4266,9 +4863,8 @@ All monitoring checks are passing normally.`;
                     }
                     const body = msg["body"];
                     let text = (body === null || body === void 0 ? void 0 : body["content"]) || "";
-                    // Remove HTML tags if present (Teams uses HTML)
-                    text = text.replace(/<[^>]*>/g, "");
-                    text = text.trim();
+                    // Teams message bodies are HTML.
+                    text = this.stripHtmlTags(text).trim();
                     // Skip empty messages
                     if (!text) {
                         continue;
@@ -4323,6 +4919,8 @@ MicrosoftTeamsUtil.AI_OPS_ACK_TEXT = "Looking into it…";
  * engine also clamps history internally, but we keep the payload small.
  */
 MicrosoftTeamsUtil.AI_OPS_MAX_HISTORY_TURNS = 12;
+// Refreshes in progress, by project: a second click joins the first.
+MicrosoftTeamsUtil.chatNameRefreshesInFlight = new Map();
 export default MicrosoftTeamsUtil;
 __decorate([
     CaptureSpan(),
@@ -4618,6 +5216,24 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], MicrosoftTeamsUtil, "removeChatFromProjectAuthTokens", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "getGroupChatTopicFromGraph", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "runChatNameRefresh", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "renameChatsInProjectAuthTokens", null);
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),