@oneuptime/common 11.3.24 → 11.3.26

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

@@ -39,6 +39,7 @@ import MicrosoftTeamsIncidentEpisodeActions from "./Actions/IncidentEpisode";
 import MicrosoftTeamsMonitorActions from "./Actions/Monitor";
 import MicrosoftTeamsScheduledMaintenanceActions from "./Actions/ScheduledMaintenance";
 import MicrosoftTeamsOnCallDutyActions from "./Actions/OnCallDutyPolicy";
+import AccessTokenService from "../../../Services/AccessTokenService";
 // Microsoft Teams apps should always be single-tenant
 const MICROSOFT_TEAMS_APP_TYPE = "SingleTenant";
 // Maximum number of pages to fetch when paginating teams
@@ -1215,7 +1216,7 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
     }
     // Bot Framework specific methods
     static async handleBotMessageActivity(data) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         // Handle direct messages to bot or @mentions via Bot Framework
         const messageText = data.activity["text"] || "";
         const possibleActionValue = data.activity["value"] || {};
@@ -1228,9 +1229,23 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
         logger.debug(`Conversation: ${JSON.stringify(conversation)}`);
         logger.debug(`Channel data: ${JSON.stringify(channelData)}`);
         logger.debug(`Entities: ${JSON.stringify(entities)}`);
+        /*
+         * Loop-guard: never process the bot's own messages. Teams generally does not
+         * echo the bot to itself, but if the sender is the bot recipient (same id) or
+         * is flagged with the "bot" role, ignore the activity to avoid a self-reply
+         * loop when routing free-form text to the AI assistant.
+         */
+        const senderId = from["id"] || "";
+        const botRecipientId = (_a = data.activity["recipient"]) === null || _a === void 0 ? void 0 : _a["id"];
+        const senderRole = from["role"] || "";
+        if (senderRole === "bot" ||
+            (senderId && botRecipientId && senderId === botRecipientId)) {
+            logger.debug("Message activity originates from the bot itself; ignoring to prevent a loop");
+            return;
+        }
         // If this is actually an Adaptive Card submit wrapped as a message, route to invoke handler
         if (possibleActionValue["action"] ||
-            ((_a = possibleActionValue["data"]) === null || _a === void 0 ? void 0 : _a["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,
@@ -1239,7 +1254,7 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
             return;
         }
         // Check if the bot was mentioned
-        const recipientId = (_b = data.activity["recipient"]) === null || _b === void 0 ? void 0 : _b["id"];
+        const recipientId = (_c = data.activity["recipient"]) === null || _c === void 0 ? void 0 : _c["id"];
         const conversationType = conversation["conversationType"] || "";
         const isDirectMessage = conversationType === "personal";
         const isMentioned = entities.some((entity) => {
@@ -1253,7 +1268,7 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
             return;
         }
         // Extract tenant ID to get project ID
-        const tenantId = (_c = channelData["tenant"]) === null || _c === void 0 ? void 0 : _c["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.");
@@ -1287,13 +1302,40 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
             .replace(/<at[^>]*>.*?<\/at>/g, "")
             .trim()
             .toLowerCase();
+        /*
+         * Preserve the original casing of the user's question. The AI assistant
+         * should receive the free-form text exactly as the user typed it (case,
+         * punctuation and spacing all matter), with only the bot @mention stripped.
+         */
+        const originalQuestionText = messageText
+            .replace(/<at[^>]*>.*?<\/at>/g, "")
+            .trim();
         let responseText = "";
         try {
             const isCreateIncidentCommand = cleanText === "create incident" ||
                 cleanText.startsWith("create incident ");
             const isCreateMaintenanceCommand = cleanText === "create maintenance" ||
                 cleanText.startsWith("create maintenance ");
-            if (cleanText.includes("help") || cleanText === "") {
+            /*
+             * 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 ");
+            if (isHelpCommand) {
                 responseText = this.getHelpMessage();
             }
             else if (isCreateIncidentCommand) {
@@ -1326,24 +1368,40 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
                 logger.debug("New scheduled maintenance card sent successfully");
                 return;
             }
-            else if (cleanText.includes("show active incidents") ||
-                cleanText.includes("active incidents")) {
+            else if (isShowActiveIncidentsCommand) {
                 responseText = await this.getActiveIncidentsMessage(projectId);
             }
-            else if (cleanText.includes("show scheduled maintenance") ||
-                cleanText.includes("scheduled maintenance")) {
+            else if (isShowScheduledMaintenanceCommand) {
                 responseText = await this.getScheduledMaintenanceMessage(projectId);
             }
-            else if (cleanText.includes("show ongoing maintenance") ||
-                cleanText.includes("ongoing maintenance")) {
+            else if (isShowOngoingMaintenanceCommand) {
                 responseText = await this.getOngoingMaintenanceMessage(projectId);
             }
-            else if (cleanText.includes("show active alerts") ||
-                cleanText.includes("active alerts")) {
+            else if (isShowActiveAlertsCommand) {
                 responseText = await this.getActiveAlertsMessage(projectId);
             }
             else {
-                responseText = `I received your message: "${cleanText}". Type 'help' to see what I can do for you.`;
+                /*
+                 * AI Ops: any message that is not one of the explicit commands above is
+                 * treated as a natural-language question for the observability
+                 * assistant. This also handles the explicit "ask <question>" prefix.
+                 */
+                const question = isAskCommand
+                    ? originalQuestionText.replace(/^ask\s*/i, "").trim()
+                    : originalQuestionText;
+                if (!question) {
+                    // Bare "ask" with no question - point the user at help.
+                    responseText = this.getHelpMessage();
+                    await data.turnContext.sendActivity(responseText);
+                    return;
+                }
+                await this.answerObservabilityQuestion({
+                    activity: data.activity,
+                    turnContext: data.turnContext,
+                    projectId: projectId,
+                    question: question,
+                });
+                return;
             }
             // Send response directly using TurnContext - this is the recommended Bot Framework pattern
             await data.turnContext.sendActivity(responseText);
@@ -1359,12 +1417,290 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
             throw error;
         }
     }
+    /*
+     * AI Ops: strip a Teams message body down to plain text - remove <at> bot
+     * mentions and any remaining HTML tags, collapse whitespace, and trim. Teams
+     * channel/chat message bodies are typically HTML (body.contentType "html").
+     */
+    static toPlainTextFromTeamsMessageBody(rawContent) {
+        return rawContent
+            .replace(/<at[^>]*>.*?<\/at>/g, "")
+            .replace(/<[^>]*>/g, "")
+            .replace(/&nbsp;/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+    }
+    /*
+     * 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,
+     * excluding the current triggering message).
+     *
+     * Teams limitation: in channels a bot only receives messages that @mention it
+     * (unless RSC / ChannelMessage.Read.Group is granted at install time), so
+     * channel follow-ups generally require re-@mentioning the bot. 1:1 (personal)
+     * chat follow-ups do not require a mention. If ids can't be parsed or the
+     * Graph call fails, we degrade gracefully to no history - the caller wraps
+     * this in a try/catch and never lets a history failure break the reply.
+     */
+    static async getConversationHistoryTurns(data) {
+        var _a, _b, _c;
+        const { activity, projectId } = data;
+        const conversation = activity["conversation"] || {};
+        const channelData = activity["channelData"] || {};
+        const conversationType = conversation["conversationType"] || "";
+        const conversationId = conversation["id"] || "";
+        const currentMessageId = activity["id"] || "";
+        /*
+         * The bot's id - used to classify each message as "assistant" (from the
+         * bot) vs "user". This is the same id the loop-guard compares against.
+         */
+        const botId = ((_a = activity["recipient"]) === null || _a === void 0 ? void 0 : _a["id"]) ||
+            MicrosoftTeamsAppClientId ||
+            "";
+        if (!conversationId) {
+            return [];
+        }
+        // Acquire a Graph app token using the same mechanism the rest of this file uses.
+        const accessToken = await this.getValidAccessToken({
+            authToken: "",
+            projectId: projectId,
+        });
+        // Collect raw Graph message objects (unordered; we sort at the end).
+        let rawMessages = [];
+        if (conversationType === "personal") {
+            /*
+             * 1:1 chat: conversation.id is the chat id. Fetch recent chat messages.
+             */
+            const chatId = conversationId;
+            const response = await API.get({
+                url: URL.fromString(`https://graph.microsoft.com/v1.0/chats/${encodeURIComponent(chatId)}/messages?$top=20`),
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            if (response instanceof HTTPErrorResponse) {
+                logger.debug("Failed to fetch 1:1 chat history for AI Ops context");
+                logger.debug(response);
+                return [];
+            }
+            rawMessages = response.data["value"] || [];
+        }
+        else {
+            /*
+             * Channel thread: conversation.id encodes the root message id as
+             * "<channelId>;messageid=<rootId>". Team & channel ids come from
+             * channelData. Fetch the root message plus its replies.
+             */
+            const teamId = (_b = channelData["team"]) === null || _b === void 0 ? void 0 : _b["id"];
+            const channelId = (_c = channelData["channel"]) === null || _c === void 0 ? void 0 : _c["id"];
+            const messageIdMatch = conversationId.match(/messageid=(\d+)/);
+            const rootMessageId = messageIdMatch === null || messageIdMatch === void 0 ? void 0 : messageIdMatch[1];
+            if (!teamId || !channelId || !rootMessageId) {
+                logger.debug("Could not parse team/channel/root message ids for AI Ops channel history; proceeding without history");
+                return [];
+            }
+            // Fetch replies in the thread.
+            const repliesResponse = await API.get({
+                url: URL.fromString(`https://graph.microsoft.com/v1.0/teams/${teamId}/channels/${channelId}/messages/${rootMessageId}/replies?$top=20`),
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            if (repliesResponse instanceof HTTPErrorResponse) {
+                logger.debug("Failed to fetch channel thread replies for AI Ops context");
+                logger.debug(repliesResponse);
+            }
+            else {
+                rawMessages =
+                    repliesResponse.data["value"] || [];
+            }
+            // Also fetch the root message so the original question is part of context.
+            const rootResponse = await API.get({
+                url: URL.fromString(`https://graph.microsoft.com/v1.0/teams/${teamId}/channels/${channelId}/messages/${rootMessageId}`),
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            if (!(rootResponse instanceof HTTPErrorResponse) && rootResponse.data) {
+                rawMessages.push(rootResponse.data);
+            }
+        }
+        // Map each Graph message to a { role, content, createdAt, id } tuple.
+        const mappedTurns = [];
+        for (const message of rawMessages) {
+            const messageId = message["id"] || "";
+            // Exclude the current triggering message - that is the live question.
+            if (messageId && currentMessageId && messageId === currentMessageId) {
+                continue;
+            }
+            const body = message["body"] || {};
+            const rawContent = body["content"] || "";
+            const content = this.toPlainTextFromTeamsMessageBody(rawContent);
+            if (!content) {
+                continue;
+            }
+            // Skip the bot's transient "Looking into it…" acknowledgements.
+            if (content === this.AI_OPS_ACK_TEXT) {
+                continue;
+            }
+            /*
+             * Classify sender. Graph marks bot/app messages via from.application; a
+             * matching application/user id to the bot id also means it is the bot.
+             */
+            const fromObj = message["from"] || {};
+            const fromApplication = fromObj["application"] || {};
+            const fromUser = fromObj["user"] || {};
+            const fromApplicationId = fromApplication["id"] || "";
+            const fromUserId = fromUser["id"] || "";
+            const isFromBot = Boolean(fromApplication["id"]) ||
+                (botId !== "" && (fromApplicationId === botId || fromUserId === botId));
+            const role = isFromBot ? "assistant" : "user";
+            const createdAtRaw = message["createdDateTime"] || "";
+            const createdAtMs = createdAtRaw
+                ? new Date(createdAtRaw).getTime()
+                : 0;
+            mappedTurns.push({
+                role: role,
+                content: content,
+                createdAtMs: createdAtMs,
+                id: messageId,
+            });
+        }
+        // Order oldest -> newest so the assistant reads the conversation in order.
+        mappedTurns.sort((a, b) => {
+            return a.createdAtMs - b.createdAtMs;
+        });
+        // Cap to the most recent turns.
+        const cappedTurns = mappedTurns
+            .slice(-this.AI_OPS_MAX_HISTORY_TURNS)
+            .map((turn) => {
+            return { role: turn.role, content: turn.content };
+        });
+        return cappedTurns;
+    }
+    /*
+     * AI Ops: resolve the OneUptime user for the Teams sender, build their real
+     * permission props, ask the observability assistant, and reply in the same
+     * conversation with the markdown answer plus a compact "Sources" footer.
+     */
+    static async answerObservabilityQuestion(data) {
+        const { activity, turnContext, projectId, question } = data;
+        /*
+         * Resolve the Teams user. Teams identifies the sender by their Azure AD
+         * object id (aadObjectId), which is what WorkspaceUserAuthToken stores as
+         * the workspaceUserId. This mirrors how handleBotInvokeActivity resolves
+         * the acting user.
+         */
+        const fromObj = activity["from"] || {};
+        const teamsUserId = fromObj["aadObjectId"] || undefined;
+        if (!teamsUserId) {
+            logger.error("AAD Object ID (teamsUserId) not found in message activity from object", {
+                projectId: projectId.toString(),
+            });
+            await turnContext.sendActivity("Sorry, I couldn't identify you. Please try again later.");
+            return;
+        }
+        // Resolve the OneUptime user linked to this Teams user.
+        let oneUptimeUserId;
+        try {
+            oneUptimeUserId =
+                await MicrosoftTeamsAuthAction.getOneUptimeUserIdFromTeamsUserId({
+                    teamsUserId: teamsUserId,
+                    projectId: projectId,
+                });
+        }
+        catch (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.");
+            return;
+        }
+        /*
+         * Let the user know we're working on it. The assistant runs a bounded,
+         * tool-grounded agent loop and can take several seconds, so send a quick
+         * acknowledgement first.
+         */
+        try {
+            await turnContext.sendActivity(this.AI_OPS_ACK_TEXT);
+        }
+        catch (ackError) {
+            // A failed acknowledgement should not stop us from answering.
+            logger.debug("Failed to send acknowledgement activity");
+            logger.debug(ackError);
+        }
+        /*
+         * Make the assistant context-aware: gather the prior turns of this
+         * conversation/thread and pass them as history (oldest-first, excluding the
+         * current question). Any failure here is non-fatal - we simply proceed
+         * statelessly so a history problem never breaks the reply.
+         */
+        let history = [];
+        try {
+            history = await this.getConversationHistoryTurns({
+                activity: activity,
+                projectId: projectId,
+            });
+            logger.debug(`AI Ops gathered ${history.length} prior conversation turn(s) as history`, {
+                projectId: projectId.toString(),
+            });
+        }
+        catch (historyError) {
+            logger.debug("Failed to gather AI Ops conversation history; proceeding statelessly");
+            logger.debug(historyError);
+            history = [];
+        }
+        try {
+            // Build the user's real permission props - the assistant's tools run under these.
+            const props = await AccessTokenService.getDatabaseCommonInteractionPropsByUserAndProject({
+                userId: oneUptimeUserId,
+                projectId: projectId,
+            });
+            /*
+             * Loaded on demand via require(): importing the AI toolbox at module top
+             * pulls the entire observability tool graph — and its database
+             * infrastructure — into the core API module graph at import time, which
+             * trips circular-dependency init-order crashes. Teams ChatOps is the only
+             * caller, so it is resolved lazily here. A value-position dynamic
+             * import() is avoided because it fails TS1323 under the consuming
+             * projects' module configuration.
+             */
+            /* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires */
+            const ObservabilityAssistant = require("../../AI/Chat/ObservabilityAssistant").default;
+            /* eslint-enable @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires */
+            const result = await ObservabilityAssistant.answerQuestion(Object.assign(Object.assign({ projectId: projectId, userId: oneUptimeUserId, props: props, question: question }, (history.length > 0 && { history: history })), { feature: "Microsoft Teams ChatOps" }));
+            // Build a compact "Sources" footer from the server-minted citations.
+            let replyText = result.contentInMarkdown;
+            if (result.citations && result.citations.length > 0) {
+                const sourceLines = result.citations.map((citation) => {
+                    return `• ${citation.label} (${citation.rowCount} rows)`;
+                });
+                replyText += `\n\n**Sources**\n${sourceLines.join("\n")}`;
+            }
+            await turnContext.sendActivity(replyText);
+            logger.debug("AI Ops answer sent successfully using TurnContext", {
+                projectId: projectId.toString(),
+            });
+        }
+        catch (error) {
+            logger.error("Error answering observability question via AI Ops: " + error, {
+                projectId: projectId.toString(),
+            });
+            await turnContext.sendActivity("Sorry, I ran into a problem answering that question. Please try again later.");
+        }
+    }
     // Helper methods for bot commands
     static getHelpMessage() {
         return `Hello! I'm the OneUptime bot. I can help you with the following commands:
 
 **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
 - **show active incidents** - Display all currently active incidents
@@ -1372,7 +1708,7 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
 - **show ongoing maintenance** - Display currently ongoing maintenance events
 - **show active alerts** - Display all active alerts
 
-Just type any of these commands to get the information you need!`;
+You can also just ask me a question in plain language - for example, "which monitors are down right now?" - and I'll look into your observability data for you.`;
     }
     static async getActiveIncidentsMessage(projectId) {
         var _a, _b;
@@ -2045,6 +2381,10 @@ All monitoring checks are passing normally.`;
                             title: "help",
                             value: "Show quick help and useful links",
                         },
+                        {
+                            title: "ask",
+                            value: "Ask OneUptime AI about your logs, traces, metrics, incidents and monitors",
+                        },
                         {
                             title: "create incident",
                             value: "Create a new incident without leaving Teams",
@@ -2412,6 +2752,17 @@ All monitoring checks are passing normally.`;
 }
 MicrosoftTeamsUtil.cachedAdapter = null;
 MicrosoftTeamsUtil.WELCOME_CARD_STATE_KEY = "oneuptime.microsoftTeams.welcomeCardSent";
+/*
+ * AI Ops: transient acknowledgement text the bot posts before answering. We
+ * must skip these when reconstructing conversation history so the assistant
+ * never treats its own "please wait" filler as a real prior turn.
+ */
+MicrosoftTeamsUtil.AI_OPS_ACK_TEXT = "Looking into it…";
+/*
+ * AI Ops: cap on how many prior turns we feed the assistant as history. The
+ * engine also clamps history internally, but we keep the payload small.
+ */
+MicrosoftTeamsUtil.AI_OPS_MAX_HISTORY_TURNS = 12;
 export default MicrosoftTeamsUtil;
 __decorate([
     CaptureSpan(),
@@ -2617,6 +2968,18 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], MicrosoftTeamsUtil, "handleBotMessageActivity", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "getConversationHistoryTurns", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "answerObservabilityQuestion", null);
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),