n8n-nodes-msteams-botframework 1.0.0 → 1.2.0

package/README.md

@@ -4,13 +4,22 @@ Custom n8n node để tương tác với Microsoft Teams thông qua Azure Bot Fr
 
 ## Tính năng
 
-Node này cho phép bạn:
+### MS Teams Bot (Action Node)
 - ✉️ Gửi tin nhắn text đến channel hoặc user
 - 🎴 Gửi Adaptive Cards
 - 💬 Reply vào tin nhắn cụ thể
 - ✏️ Cập nhật tin nhắn đã gửi
 - 🗑️ Xóa tin nhắn
 
+### MS Teams Bot Trigger (NEW in v1.1.0) 🎣
+- 📥 Nhận tin nhắn từ Teams qua webhook
+- 👥 Nhận thông báo khi có người join/leave
+- 👍 Nhận reactions vào tin nhắn
+- ✏️ Nhận thông báo khi message được edit
+- 🗑️ Nhận thông báo khi message bị xóa
+- 🤖 Tự động filter bot messages
+- ⌨️ Tự động gửi typing indicator
+
 ## Yêu cầu
 
 - n8n version 0.187.0 trở lên

package/dist/nodes/MsTeamsBotFramework/MsTeamsAIBot.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class MsTeamsAIBot implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/MsTeamsBotFramework/MsTeamsAIBot.node.js

@@ -0,0 +1,255 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsTeamsAIBot = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const axios_1 = __importDefault(require("axios"));
+const conversationMemories = {};
+class MsTeamsAIBot {
+    constructor() {
+        this.description = {
+            displayName: 'MS Teams AI Bot',
+            name: 'msTeamsAIBot',
+            icon: 'file:msteams.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["aiProvider"]}} AI Chatbot',
+            description: 'AI-powered Teams bot with chat models, memory, and function calling',
+            defaults: {
+                name: 'MS Teams AI Bot',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'msTeamsBotFrameworkApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'AI Provider',
+                    name: 'aiProvider',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'OpenAI',
+                            value: 'openai',
+                        },
+                        {
+                            name: 'Anthropic (Claude)',
+                            value: 'anthropic',
+                        },
+                    ],
+                    default: 'openai',
+                },
+                {
+                    displayName: 'OpenAI API Key',
+                    name: 'openaiApiKey',
+                    type: 'string',
+                    typeOptions: { password: true },
+                    displayOptions: { show: { aiProvider: ['openai'] } },
+                    default: '',
+                    description: 'OpenAI API Key',
+                },
+                {
+                    displayName: 'Model',
+                    name: 'openaiModel',
+                    type: 'options',
+                    displayOptions: { show: { aiProvider: ['openai'] } },
+                    options: [
+                        { name: 'GPT-4 Turbo', value: 'gpt-4-turbo-preview' },
+                        { name: 'GPT-4', value: 'gpt-4' },
+                        { name: 'GPT-3.5 Turbo', value: 'gpt-3.5-turbo' },
+                    ],
+                    default: 'gpt-3.5-turbo',
+                },
+                {
+                    displayName: 'Anthropic API Key',
+                    name: 'anthropicApiKey',
+                    type: 'string',
+                    typeOptions: { password: true },
+                    displayOptions: { show: { aiProvider: ['anthropic'] } },
+                    default: '',
+                },
+                {
+                    displayName: 'Model',
+                    name: 'anthropicModel',
+                    type: 'options',
+                    displayOptions: { show: { aiProvider: ['anthropic'] } },
+                    options: [
+                        { name: 'Claude 3 Opus', value: 'claude-3-opus-20240229' },
+                        { name: 'Claude 3 Sonnet', value: 'claude-3-sonnet-20240229' },
+                        { name: 'Claude 3 Haiku', value: 'claude-3-haiku-20240307' },
+                    ],
+                    default: 'claude-3-sonnet-20240229',
+                },
+                {
+                    displayName: 'System Prompt',
+                    name: 'systemPrompt',
+                    type: 'string',
+                    typeOptions: { rows: 4 },
+                    default: 'You are a helpful AI assistant in Microsoft Teams. Be concise and professional.',
+                },
+                {
+                    displayName: 'Enable Memory',
+                    name: 'enableMemory',
+                    type: 'boolean',
+                    default: true,
+                },
+                {
+                    displayName: 'Memory Limit',
+                    name: 'memoryLimit',
+                    type: 'number',
+                    displayOptions: { show: { enableMemory: [true] } },
+                    default: 10,
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Temperature',
+                            name: 'temperature',
+                            type: 'number',
+                            default: 0.7,
+                        },
+                        {
+                            displayName: 'Max Tokens',
+                            name: 'maxTokens',
+                            type: 'number',
+                            default: 500,
+                        },
+                        {
+                            displayName: 'Auto Reply',
+                            name: 'autoReply',
+                            type: 'boolean',
+                            default: true,
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async execute() {
+        var _a, _b, _c;
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('msTeamsBotFrameworkApi');
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const item = items[i].json;
+                const aiProvider = this.getNodeParameter('aiProvider', i);
+                const systemPrompt = this.getNodeParameter('systemPrompt', i);
+                const enableMemory = this.getNodeParameter('enableMemory', i);
+                const memoryLimit = this.getNodeParameter('memoryLimit', i, 10);
+                const options = this.getNodeParameter('options', i, {});
+                const userMessage = item.text;
+                const conversationId = (_a = item.conversation) === null || _a === void 0 ? void 0 : _a.id;
+                const serviceUrl = item.serviceUrl;
+                if (!conversationMemories[conversationId]) {
+                    conversationMemories[conversationId] = [];
+                }
+                if (enableMemory) {
+                    conversationMemories[conversationId].push({
+                        role: 'user',
+                        content: userMessage,
+                    });
+                    if (conversationMemories[conversationId].length > memoryLimit * 2) {
+                        conversationMemories[conversationId] = conversationMemories[conversationId].slice(-memoryLimit * 2);
+                    }
+                }
+                const messages = [{ role: 'system', content: systemPrompt }];
+                if (enableMemory) {
+                    messages.push(...conversationMemories[conversationId]);
+                }
+                else {
+                    messages.push({ role: 'user', content: userMessage });
+                }
+                let aiResponse;
+                if (aiProvider === 'openai') {
+                    const apiKey = this.getNodeParameter('openaiApiKey', i);
+                    const model = this.getNodeParameter('openaiModel', i);
+                    const response = await axios_1.default.post('https://api.openai.com/v1/chat/completions', {
+                        model,
+                        messages,
+                        temperature: options.temperature || 0.7,
+                        max_tokens: options.maxTokens || 500,
+                    }, { headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' } });
+                    aiResponse = response.data.choices[0].message.content;
+                }
+                else if (aiProvider === 'anthropic') {
+                    const apiKey = this.getNodeParameter('anthropicApiKey', i);
+                    const model = this.getNodeParameter('anthropicModel', i);
+                    const systemMessage = ((_b = messages.find((m) => m.role === 'system')) === null || _b === void 0 ? void 0 : _b.content) || '';
+                    const conversationMessages = messages.filter((m) => m.role !== 'system');
+                    const response = await axios_1.default.post('https://api.anthropic.com/v1/messages', {
+                        model,
+                        messages: conversationMessages,
+                        system: systemMessage,
+                        max_tokens: options.maxTokens || 500,
+                    }, {
+                        headers: {
+                            'x-api-key': apiKey,
+                            'anthropic-version': '2023-06-01',
+                            'Content-Type': 'application/json',
+                        },
+                    });
+                    aiResponse = response.data.content
+                        .filter((c) => c.type === 'text')
+                        .map((c) => c.text)
+                        .join('\n');
+                }
+                else {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `AI provider "${aiProvider}" not implemented`);
+                }
+                if (enableMemory) {
+                    conversationMemories[conversationId].push({
+                        role: 'assistant',
+                        content: aiResponse,
+                    });
+                }
+                if (options.autoReply !== false) {
+                    const tokenResponse = await axios_1.default.post('https://login.microsoftonline.com/botframework.com/oauth2/v2.0/token', new URLSearchParams({
+                        grant_type: 'client_credentials',
+                        client_id: credentials.appId,
+                        client_secret: credentials.appPassword,
+                        scope: 'https://api.botframework.com/.default',
+                    }), { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } });
+                    await axios_1.default.post(`${serviceUrl}v3/conversations/${conversationId}/activities`, {
+                        type: 'message',
+                        text: aiResponse,
+                        channelId: 'msteams',
+                        conversation: { id: conversationId },
+                    }, {
+                        headers: {
+                            'Authorization': `Bearer ${tokenResponse.data.access_token}`,
+                            'Content-Type': 'application/json',
+                        },
+                    });
+                }
+                returnData.push({
+                    json: {
+                        userMessage,
+                        aiResponse,
+                        conversationId,
+                        memorySize: ((_c = conversationMemories[conversationId]) === null || _c === void 0 ? void 0 : _c.length) || 0,
+                    },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message } });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.MsTeamsAIBot = MsTeamsAIBot;

package/dist/nodes/MsTeamsBotFramework/MsTeamsBotFrameworkTrigger.node.d.ts

@@ -0,0 +1,12 @@
+import { IHookFunctions, IWebhookFunctions, INodeType, INodeTypeDescription, IWebhookResponseData } from 'n8n-workflow';
+export declare class MsTeamsBotFrameworkTrigger implements INodeType {
+    description: INodeTypeDescription;
+    webhookMethods: {
+        default: {
+            checkExists(this: IHookFunctions): Promise<boolean>;
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}

package/dist/nodes/MsTeamsBotFramework/MsTeamsBotFrameworkTrigger.node.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsTeamsBotFrameworkTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const botbuilder_1 = require("botbuilder");
+class MsTeamsBotFrameworkTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'MS Teams Bot Trigger',
+            name: 'msTeamsBotFrameworkTrigger',
+            icon: 'file:msteams.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: 'Receive MS Teams messages',
+            description: 'Receive messages and events from MS Teams via webhook',
+            defaults: {
+                name: 'MS Teams Bot Trigger',
+            },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'msTeamsBotFrameworkApi',
+                    required: true,
+                },
+            ],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: 'onReceived',
+                    path: 'webhook',
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Events',
+                    name: 'events',
+                    type: 'multiOptions',
+                    options: [
+                        {
+                            name: 'Message Received',
+                            value: 'message',
+                            description: 'Trigger when a message is received',
+                        },
+                        {
+                            name: 'Conversation Update',
+                            value: 'conversationUpdate',
+                            description: 'Trigger when someone joins/leaves conversation',
+                        },
+                        {
+                            name: 'Message Reaction',
+                            value: 'messageReaction',
+                            description: 'Trigger when someone reacts to a message',
+                        },
+                        {
+                            name: 'Message Update',
+                            value: 'messageUpdate',
+                            description: 'Trigger when a message is updated',
+                        },
+                        {
+                            name: 'Message Delete',
+                            value: 'messageDelete',
+                            description: 'Trigger when a message is deleted',
+                        },
+                    ],
+                    default: ['message'],
+                    required: true,
+                    description: 'The events to listen to',
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Ignore Bot Messages',
+                            name: 'ignoreBotMessages',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to ignore messages from bots',
+                        },
+                        {
+                            displayName: 'Include Raw Activity',
+                            name: 'includeRawActivity',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to include the raw Bot Framework activity in output',
+                        },
+                        {
+                            displayName: 'Auto Reply',
+                            name: 'autoReply',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to automatically send a typing indicator',
+                        },
+                    ],
+                },
+            ],
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    return true;
+                },
+                async create() {
+                    return true;
+                },
+                async delete() {
+                    return true;
+                },
+            },
+        };
+    }
+    async webhook() {
+        const credentials = await this.getCredentials('msTeamsBotFrameworkApi');
+        const req = this.getRequestObject();
+        const events = this.getNodeParameter('events', []);
+        const options = this.getNodeParameter('options', {});
+        const appId = credentials.appId;
+        const appPassword = credentials.appPassword;
+        // Create Bot Framework Adapter
+        const adapter = new botbuilder_1.BotFrameworkAdapter({
+            appId,
+            appPassword,
+        });
+        // Process the incoming activity
+        let activityData = null;
+        let shouldTrigger = false;
+        try {
+            await adapter.processActivity(req, req.res, async (context) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+                const activity = context.activity;
+                // Check if we should process this activity type
+                if (!events.includes(activity.type)) {
+                    return;
+                }
+                // Ignore bot messages if configured
+                if (options.ignoreBotMessages && ((_a = activity.from) === null || _a === void 0 ? void 0 : _a.role) === 'bot') {
+                    return;
+                }
+                shouldTrigger = true;
+                // Send typing indicator if auto reply is enabled
+                if (options.autoReply && activity.type === 'message') {
+                    await context.sendActivity({ type: 'typing' });
+                }
+                // Extract useful data from activity
+                activityData = {
+                    type: activity.type,
+                    text: activity.text,
+                    timestamp: activity.timestamp,
+                    id: activity.id,
+                    conversation: {
+                        id: (_b = activity.conversation) === null || _b === void 0 ? void 0 : _b.id,
+                        name: (_c = activity.conversation) === null || _c === void 0 ? void 0 : _c.name,
+                        conversationType: (_d = activity.conversation) === null || _d === void 0 ? void 0 : _d.conversationType,
+                        tenantId: (_e = activity.conversation) === null || _e === void 0 ? void 0 : _e.tenantId,
+                    },
+                    from: {
+                        id: (_f = activity.from) === null || _f === void 0 ? void 0 : _f.id,
+                        name: (_g = activity.from) === null || _g === void 0 ? void 0 : _g.name,
+                        aadObjectId: (_h = activity.from) === null || _h === void 0 ? void 0 : _h.aadObjectId,
+                        role: (_j = activity.from) === null || _j === void 0 ? void 0 : _j.role,
+                    },
+                    recipient: {
+                        id: (_k = activity.recipient) === null || _k === void 0 ? void 0 : _k.id,
+                        name: (_l = activity.recipient) === null || _l === void 0 ? void 0 : _l.name,
+                    },
+                    channelId: activity.channelId,
+                    serviceUrl: activity.serviceUrl,
+                    locale: activity.locale,
+                };
+                // Add type-specific data
+                switch (activity.type) {
+                    case 'message':
+                        activityData.message = {
+                            text: activity.text,
+                            textFormat: activity.textFormat,
+                            attachments: activity.attachments,
+                            mentions: (_m = activity.entities) === null || _m === void 0 ? void 0 : _m.filter((e) => e.type === 'mention'),
+                        };
+                        break;
+                    case 'conversationUpdate':
+                        activityData.conversationUpdate = {
+                            membersAdded: activity.membersAdded,
+                            membersRemoved: activity.membersRemoved,
+                        };
+                        break;
+                    case 'messageReaction':
+                        activityData.messageReaction = {
+                            reactionsAdded: activity.reactionsAdded,
+                            reactionsRemoved: activity.reactionsRemoved,
+                            replyToId: activity.replyToId,
+                        };
+                        break;
+                    case 'messageUpdate':
+                        activityData.messageUpdate = {
+                            text: activity.text,
+                            updatedText: activity.text,
+                        };
+                        break;
+                    case 'messageDelete':
+                        activityData.messageDelete = {
+                            deletedMessageId: activity.id,
+                        };
+                        break;
+                }
+                // Include raw activity if requested
+                if (options.includeRawActivity) {
+                    activityData.rawActivity = activity;
+                }
+            });
+            if (!shouldTrigger) {
+                // Return empty response if we shouldn't trigger
+                return {
+                    workflowData: [],
+                };
+            }
+            // Return the activity data to the workflow
+            return {
+                workflowData: [
+                    [
+                        {
+                            json: activityData,
+                        },
+                    ],
+                ],
+            };
+        }
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to process Teams webhook: ${error.message}`, {
+                description: error.message,
+            });
+        }
+    }
+}
+exports.MsTeamsBotFrameworkTrigger = MsTeamsBotFrameworkTrigger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-msteams-botframework",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "n8n node for MS Teams Azure Bot Framework",
   "keywords": [
     "n8n-community-node-package",
@@ -38,7 +38,9 @@
       "dist/credentials/MsTeamsBotFrameworkApi.credentials.js"
     ],
     "nodes": [
-      "dist/nodes/MsTeamsBotFramework/MsTeamsBotFramework.node.js"
+      "dist/nodes/MsTeamsBotFramework/MsTeamsBotFramework.node.js",
+      "dist/nodes/MsTeamsBotFramework/MsTeamsBotFrameworkTrigger.node.js",
+      "dist/nodes/MsTeamsBotFramework/MsTeamsAIBot.node.js"
     ]
   },
   "devDependencies": {