n8n-nodes-bgos 1.3.4 → 1.4.1

package/dist/nodes/BGOSAction/BGOSAction.node.js

@@ -11,8 +11,9 @@ class BGOSAction {
         group: ['transform'],
         version: 1,
         subtitle: '={{$parameter["resource"] + ": " + $parameter["operation"]}}',
-        description: 'Interact with the BGOS platform',
+        description: 'Interact with the BGOS chat platform. Send/edit/pin/delete messages, ask the user a question, send a message and wait for the reply, fetch chat metadata, manage assistants and files. Usable as an AI agent tool.',
         defaults: { name: 'BGOS Action' },
+        usableAsTool: true,
         inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
         outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
         credentials: [
@@ -45,22 +46,40 @@ class BGOSAction {
                 noDataExpression: true,
                 displayOptions: { show: { resource: ['message'] } },
                 options: [
-                    {
-                        name: 'Delete a Message',
-                        value: 'deleteMessage',
-                        description: 'Delete a message from a chat',
-                        action: 'Delete a message',
-                    },
                     {
                         name: 'Send a Message',
                         value: 'sendMessage',
-                        description: 'Send an assistant reply to the user with optional file attachment',
+                        description: 'Post a new message to a chat. Use for proactive notifications, assistant replies, status updates, or anything you want to say to the user or another agent. Supports text, file attachments, and tappable inline/modal buttons.',
                         action: 'Send a message',
                     },
+                    {
+                        name: 'Send and Wait for Reply',
+                        value: 'sendAndWaitForReply',
+                        description: 'Post a message and BLOCK until the next reply arrives in the chat (default 10 min timeout). Use this when an AI agent calls another agent (or the user) and needs the response back as the tool result. Returns { sentMessageId, replyMessageId, replyText }.',
+                        action: 'Send a message and wait for reply',
+                    },
+                    {
+                        name: 'Edit a Message',
+                        value: 'editMessage',
+                        description: 'Replace the text of a previously-sent message in place. Use to update a status message ("Working..." → "Done") instead of spamming new messages. Requires Message ID and User ID.',
+                        action: 'Edit a message',
+                    },
+                    {
+                        name: 'Pin or Unpin a Message',
+                        value: 'pinMessage',
+                        description: 'Toggle the pinned state of a message. Pinned messages appear in the chat\'s pin bar. Set "Is Pinned" to true to pin or false to unpin.',
+                        action: 'Pin or unpin a message',
+                    },
+                    {
+                        name: 'Delete a Message',
+                        value: 'deleteMessage',
+                        description: 'Permanently remove a message from a chat. Use sparingly — most workflows should edit the text rather than delete + resend.',
+                        action: 'Delete a message',
+                    },
                     {
                         name: 'Ask User Input',
                         value: 'askUserInput',
-                        description: 'Ask the user 1–4 multiple-choice questions through the polished modal/sheet in the BGOS app',
+                        description: 'Ask the user 1–4 multiple-choice questions through a polished modal/sheet (or inline carousel). BLOCKS until answered. Use ONLY when the user is actively in conversation and you need their immediate choice; for async/scheduled prompts use Send a Message with buttons instead.',
                         action: 'Ask user input',
                     },
                 ],
@@ -76,25 +95,31 @@ class BGOSAction {
                 displayOptions: { show: { resource: ['chat'] } },
                 options: [
                     {
-                        name: 'Delete a Chat',
-                        value: 'deleteChat',
-                        description: 'Delete a chat',
-                        action: 'Delete a chat',
+                        name: 'Get a Chat',
+                        value: 'getChat',
+                        description: 'Fetch chat metadata (title, assistant, ownership, timestamps) by chat ID. Use to gather context before deciding how to respond — e.g. checking the assigned assistant or the chat title.',
+                        action: 'Get a chat',
+                    },
+                    {
+                        name: 'Set Title on a Chat',
+                        value: 'renameChat',
+                        description: 'Rename a chat. Use after a meaningful event (e.g. summarising the topic of a conversation, or marking a chat as resolved).',
+                        action: 'Set title on a chat',
                     },
                     {
                         name: 'Save Chat History',
                         value: 'saveChatHistory',
-                        description: 'Bulk-save messages to a chat',
+                        description: 'Bulk-insert a list of messages into a chat. Use for migrations or for replaying conversation history; not for normal sending — use "Send a Message" for that.',
                         action: 'Save chat history',
                     },
                     {
-                        name: 'Set Title on a Chat',
-                        value: 'renameChat',
-                        description: 'Rename a chat',
-                        action: 'Set title on a chat',
+                        name: 'Delete a Chat',
+                        value: 'deleteChat',
+                        description: 'Permanently delete a chat and its messages. Destructive — use only for explicit cleanup tasks.',
+                        action: 'Delete a chat',
                     },
                 ],
-                default: 'renameChat',
+                default: 'getChat',
                 required: true,
             },
             // ── Assistant operations ──────────────────────────────────────────────
@@ -251,6 +276,133 @@ class BGOSAction {
                 description: 'ID of the message to delete. Falls back to message_id / messageId from input data.',
                 displayOptions: { show: { resource: ['message'], operation: ['deleteMessage'] } },
             },
+            // ── Edit a Message ────────────────────────────────────────────────────
+            {
+                displayName: 'Message ID',
+                name: 'messageId',
+                type: 'string',
+                default: '',
+                placeholder: '456',
+                description: 'ID of the message to edit. Falls back to message_id / messageId from input data.',
+                displayOptions: { show: { resource: ['message'], operation: ['editMessage'] } },
+            },
+            {
+                displayName: 'New Text',
+                name: 'messageText',
+                type: 'string',
+                typeOptions: { rows: 4 },
+                default: '',
+                placeholder: 'Done — here\'s the result:',
+                description: 'The new message text. Replaces the existing text entirely. Falls back to the input data\'s text field.',
+                displayOptions: { show: { resource: ['message'], operation: ['editMessage'] } },
+            },
+            {
+                displayName: 'User ID',
+                name: 'userId',
+                type: 'string',
+                default: '',
+                placeholder: 'user_xxx',
+                description: 'User ID of the message owner (for ownership validation). Falls back to user_id from input data.',
+                displayOptions: { show: { resource: ['message'], operation: ['editMessage'] } },
+            },
+            // ── Pin or Unpin a Message ────────────────────────────────────────────
+            {
+                displayName: 'Message ID',
+                name: 'messageId',
+                type: 'string',
+                default: '',
+                placeholder: '456',
+                description: 'ID of the message to pin or unpin. Falls back to message_id / messageId from input data.',
+                displayOptions: { show: { resource: ['message'], operation: ['pinMessage'] } },
+            },
+            {
+                displayName: 'Is Pinned',
+                name: 'isPinned',
+                type: 'boolean',
+                default: true,
+                description: 'Whether the message should be pinned (true) or unpinned (false). Pinned messages appear in the chat\'s pin bar.',
+                displayOptions: { show: { resource: ['message'], operation: ['pinMessage'] } },
+            },
+            // ── Send and Wait for Reply ───────────────────────────────────────────
+            {
+                displayName: 'Assistant ID',
+                name: 'assistantId',
+                type: 'string',
+                default: '',
+                placeholder: '42',
+                description: 'ID of the assistant sending the message. Falls back to assistantId / assistant_id from input data.',
+                displayOptions: { show: { resource: ['message'], operation: ['sendAndWaitForReply'] } },
+            },
+            {
+                displayName: 'Chat ID',
+                name: 'chatId',
+                type: 'string',
+                default: '',
+                placeholder: '123',
+                description: 'ID of the chat to post into and listen on. Falls back to chatId / chat_id from input data.',
+                displayOptions: { show: { resource: ['message'], operation: ['sendAndWaitForReply'] } },
+            },
+            {
+                displayName: 'Text',
+                name: 'messageText',
+                type: 'string',
+                typeOptions: { rows: 4 },
+                default: '',
+                placeholder: 'Hey Ava, can you check on the latest sales numbers?',
+                description: 'Message text to post. The next reply in the chat will be returned as the tool result.',
+                displayOptions: { show: { resource: ['message'], operation: ['sendAndWaitForReply'] } },
+            },
+            {
+                displayName: 'Additional Fields',
+                name: 'replyAdditionalFields',
+                type: 'collection',
+                placeholder: 'Add Field',
+                default: {},
+                displayOptions: { show: { resource: ['message'], operation: ['sendAndWaitForReply'] } },
+                options: [
+                    {
+                        displayName: 'Sender',
+                        name: 'sender',
+                        type: 'options',
+                        default: 'assistant',
+                        options: [
+                            { name: 'Assistant', value: 'assistant' },
+                            { name: 'User', value: 'user' },
+                        ],
+                        description: 'Who is sending the outgoing message. Defaults to Assistant.',
+                    },
+                    {
+                        displayName: 'File ID',
+                        name: 'fileId',
+                        type: 'string',
+                        default: '',
+                        placeholder: 'abc-123',
+                        description: 'ID of a previously uploaded file to attach to the outgoing message. Use the "Upload a File" operation first to get the file ID.',
+                    },
+                    {
+                        displayName: 'User ID',
+                        name: 'userId',
+                        type: 'string',
+                        default: '',
+                        placeholder: 'user_xxx',
+                        description: 'User ID that owns the chat (required by the poll endpoint). Auto-falls-back to user_id / userId on the input data — typically passed in by an upstream BGOS Trigger — so most workflows can leave this empty.',
+                    },
+                    {
+                        displayName: 'Timeout (Seconds)',
+                        name: 'replyTimeoutSeconds',
+                        type: 'number',
+                        default: 600,
+                        description: 'How long to wait for a reply before failing the node (default 10 minutes).',
+                    },
+                    {
+                        displayName: 'Poll Interval (Ms)',
+                        name: 'replyPollIntervalMs',
+                        type: 'number',
+                        default: 2000,
+                        description: 'How often to check for new messages while waiting (default 2 seconds; minimum 1000).',
+                    },
+                ],
+            },
             // ── Ask User Input ────────────────────────────────────────────────────
             {
                 displayName: 'Chat ID',
@@ -395,7 +547,7 @@ class BGOSAction {
                 default: '',
                 placeholder: '123',
                 description: 'ID of the chat. Falls back to chat_id / chat.id from input data.',
-                displayOptions: { show: { resource: ['chat'], operation: ['renameChat', 'deleteChat', 'saveChatHistory'] } },
+                displayOptions: { show: { resource: ['chat'], operation: ['renameChat', 'deleteChat', 'saveChatHistory', 'getChat'] } },
             },
             {
                 displayName: 'New Title',
@@ -557,7 +709,7 @@ class BGOSAction {
                 type: 'string',
                 default: '',
                 placeholder: 'user_xxx',
-                description: 'Override the user ID. If empty, falls back to user_id from the input data.',
+                description: 'Override the user ID. If empty, falls back to user_id from the input data. Optional for "Get a Chat".',
                 displayOptions: {
                     show: {
                         resource: ['chat', 'assistant', 'callback', 'file'],
@@ -599,6 +751,30 @@ class BGOSAction {
                 if (operation === 'deleteMessage') {
                     nodeParams.deleteMessageId = String(this.getNodeParameter('deleteMessageId', i, '') ?? '');
                 }
+                if (operation === 'editMessage') {
+                    nodeParams.messageId = String(this.getNodeParameter('messageId', i, '') ?? '');
+                    nodeParams.messageText = String(this.getNodeParameter('messageText', i, '') ?? '');
+                    nodeParams.userId = String(this.getNodeParameter('userId', i, '') ?? '');
+                }
+                if (operation === 'pinMessage') {
+                    nodeParams.messageId = String(this.getNodeParameter('messageId', i, '') ?? '');
+                    nodeParams.isPinned = Boolean(this.getNodeParameter('isPinned', i, true));
+                }
+                if (operation === 'sendAndWaitForReply') {
+                    nodeParams.assistantId = String(this.getNodeParameter('assistantId', i, '') ?? '');
+                    nodeParams.chatId = String(this.getNodeParameter('chatId', i, '') ?? '');
+                    nodeParams.messageText = String(this.getNodeParameter('messageText', i, '') ?? '');
+                    const replyAdditional = this.getNodeParameter('replyAdditionalFields', i, {});
+                    nodeParams.userId = String(replyAdditional.userId ?? '');
+                    nodeParams.sender = String(replyAdditional.sender ?? 'assistant');
+                    nodeParams.fileId = String(replyAdditional.fileId ?? '');
+                    nodeParams.replyTimeoutSeconds = Number(replyAdditional.replyTimeoutSeconds ?? 600);
+                    nodeParams.replyPollIntervalMs = Number(replyAdditional.replyPollIntervalMs ?? 2000);
+                }
+                if (operation === 'getChat') {
+                    nodeParams.chatId = String(this.getNodeParameter('chatId', i, '') ?? '');
+                    nodeParams.userId = String(this.getNodeParameter('userId', i, '') ?? '');
+                }
                 if (operation === 'askUserInput') {
                     nodeParams.chatId = String(this.getNodeParameter('chatId', i, '') ?? '');
                     nodeParams.userId = String(this.getNodeParameter('askUserId', i, '') ?? '');

package/dist/nodes/BGOSAction/handler/eventHandler.d.ts

@@ -38,6 +38,9 @@ type NodeParams = {
     askTimeoutSeconds?: number;
     askPollIntervalMs?: number;
     renderMode?: string;
+    isPinned?: boolean;
+    replyTimeoutSeconds?: number;
+    replyPollIntervalMs?: number;
     [key: string]: unknown;
 };
 export declare function handleEventByType(this: IExecuteFunctions, eventType: string, eventData: Record<string, unknown>, nodeParams: NodeParams): Promise<unknown>;

package/dist/nodes/BGOSAction/handler/eventHandler.js

@@ -81,6 +81,86 @@ async function handleEventByType(eventType, eventData, nodeParams) {
             }
             return await techWebhook_1.deleteMessage.call(this, apiOptions, String(messageId));
         }
+        case 'editMessage': {
+            const apiOptions = getApiOptions(nodeParams);
+            const messageId = nodeParams.messageId || (eventData.message_id ?? eventData.messageId ?? message?.id);
+            const userId = (nodeParams.userId ?? eventData.user_id ?? eventData.userId);
+            const newText = (nodeParams.messageText ?? '').trim() || (eventData.text ?? message?.text ?? '');
+            if (!messageId || !userId || !newText) {
+                throw new Error('Message ID, User ID, and Text are required for Edit a Message. Set the fields or make sure input data contains message_id, user_id, and text.');
+            }
+            return await techWebhook_1.editMessageText.call(this, apiOptions, userId, String(messageId), String(newText));
+        }
+        case 'pinMessage': {
+            const apiOptions = getApiOptions(nodeParams);
+            const messageId = nodeParams.messageId || (eventData.message_id ?? eventData.messageId ?? message?.id);
+            if (!messageId) {
+                throw new Error('Message ID is required for Pin/Unpin a Message. Set the field or make sure input data contains message_id.');
+            }
+            // pinState may come from the node param or input data; default to true (pin)
+            const pinStateRaw = nodeParams.isPinned ?? eventData.isPinned ?? eventData.is_pinned ?? true;
+            const isPinned = pinStateRaw === true || pinStateRaw === 'true';
+            return await techWebhook_1.setMessagePinned.call(this, apiOptions, String(messageId), isPinned);
+        }
+        case 'sendAndWaitForReply': {
+            const apiOptions = getApiOptions(nodeParams);
+            const assistantId = nodeParams.assistantId || (eventData.assistantId ?? eventData.assistant_id ?? assistant?.id);
+            const chatId = nodeParams.chatId || (eventData.chatId ?? eventData.chat_id ?? chat?.id ?? message?.chatId);
+            const userId = ((nodeParams.userId && String(nodeParams.userId).trim()) || eventData.user_id || eventData.userId);
+            const text = (nodeParams.messageText ?? '').trim() || (eventData.text ?? message?.text ?? '');
+            if (!assistantId || !chatId || !userId || !text) {
+                throw new Error('Assistant ID, Chat ID, Text, and a User ID (from input data or the Additional Fields override) are required for Send and Wait for Reply. Make sure the upstream BGOS Trigger output includes user_id.');
+            }
+            // Optional file attachment
+            const fileIdParam = nodeParams.fileId?.trim();
+            const files = fileIdParam ? [{ id: fileIdParam }] : [];
+            const sender = nodeParams.sender || 'assistant';
+            // Step 1: post the outgoing message and capture its id
+            const sendResult = (await techWebhook_1.sendMessageToBackend.call(this, apiOptions, {
+                assistantId: assistantId,
+                chatId: chatId,
+                sender,
+                text,
+                files,
+                isMixedAttachments: files.length > 0 ? true : null,
+            }));
+            const sentMessageId = Number(sendResult?.id
+                ?? sendResult?.message?.id
+                ?? 0);
+            if (!sentMessageId) {
+                throw new Error('Could not determine sent message ID from BGOS response — cannot wait for reply.');
+            }
+            // Step 2: poll the chat for any new message with id > sentMessageId
+            const timeoutSeconds = Number(nodeParams.replyTimeoutSeconds ?? 600);
+            const pollIntervalMs = Math.max(1000, Number(nodeParams.replyPollIntervalMs ?? 2000));
+            const deadline = Date.now() + timeoutSeconds * 1000;
+            while (Date.now() < deadline) {
+                await new Promise((r) => setTimeout(r, pollIntervalMs));
+                try {
+                    const data = await techWebhook_1.getChatMessages.call(this, apiOptions, Number(chatId), userId);
+                    // Cast to a permissive shape — backend returns extra fields beyond ChatMessageEntry
+                    const msgs = (data?.messages ?? []);
+                    for (const entry of msgs) {
+                        const m = (entry.message ?? entry);
+                        const id = Number(m.id ?? 0);
+                        const replyText = m.text;
+                        if (id > sentMessageId && replyText) {
+                            return {
+                                success: true,
+                                sentMessageId,
+                                replyMessageId: id,
+                                replyText,
+                                raw: entry,
+                            };
+                        }
+                    }
+                }
+                catch {
+                    // Network blip — keep polling.
+                }
+            }
+            throw new Error(`Timed out after ${timeoutSeconds}s waiting for a reply to message ${sentMessageId} in chat ${chatId}.`);
+        }
         case 'askUserInput': {
             const apiOptions = getApiOptions(nodeParams);
             const chatId = nodeParams.chatId || (eventData.chatId ?? eventData.chat_id ?? chat?.id ?? message?.chatId);
@@ -243,6 +323,14 @@ async function handleEventByType(eventType, eventData, nodeParams) {
                 throw new Error('Chat ID is required for Delete a Chat.');
             return await techWebhook_1.deleteChat.call(this, getApiOptions(nodeParams), userId, String(chatId));
         }
+        case 'getChat': {
+            const apiOptions = getApiOptions(nodeParams);
+            const chatId = nodeParams.chatId || (eventData.chat_id ?? eventData.chatId ?? chat?.id);
+            if (!chatId)
+                throw new Error('Chat ID is required for Get a Chat.');
+            const userId = (nodeParams.userId ?? eventData.user_id ?? eventData.userId);
+            return await techWebhook_1.getChat.call(this, apiOptions, String(chatId), userId);
+        }
         case 'saveChatHistory': {
             const userId = (nodeParams.userId ?? eventData.user_id ?? eventData.userId);
             if (!userId)

package/dist/nodes/BGOSAction/techWebhook.d.ts

@@ -18,6 +18,24 @@ export declare function saveChatHistory(this: IExecuteFunctions, options: BgosAp
 export declare function deleteMessage(this: IExecuteFunctions, options: BgosApiOptions, messageId: string | number): Promise<{
     success: boolean;
 }>;
+/**
+ * PATCH /api/v1/messages/:id — update the text of an existing message.
+ * Useful for status-updates-in-place (e.g. "Working..." → "Done"), replacing
+ * the prior approach of sending a new message every time.
+ */
+export declare function editMessageText(this: IExecuteFunctions, options: BgosApiOptions, userId: string, messageId: string | number, text: string): Promise<unknown>;
+/**
+ * PATCH /api/v1/messages/:id/pin — toggle the pin state of a message.
+ * Body { isPinned: boolean }. Backend stamps pinned_at when true,
+ * clears it when false. Emits a message_pinned WebSocket event.
+ */
+export declare function setMessagePinned(this: IExecuteFunctions, options: BgosApiOptions, messageId: string | number, isPinned: boolean): Promise<unknown>;
+/**
+ * GET /api/v1/chats/:chatId?userId=... — fetch chat metadata (title,
+ * assistantId, ownership). Useful for AI agents that need context before
+ * deciding how to respond.
+ */
+export declare function getChat(this: IExecuteFunctions, options: BgosApiOptions, chatId: string | number, userId?: string): Promise<unknown>;
 export declare function sendMessageToBackend(this: IExecuteFunctions, options: BgosApiOptions, payload: {
     assistantId: string | number;
     chatId: string | number;

package/dist/nodes/BGOSAction/techWebhook.js

@@ -7,6 +7,9 @@ exports.renameChat = renameChat;
 exports.deleteChat = deleteChat;
 exports.saveChatHistory = saveChatHistory;
 exports.deleteMessage = deleteMessage;
+exports.editMessageText = editMessageText;
+exports.setMessagePinned = setMessagePinned;
+exports.getChat = getChat;
 exports.sendMessageToBackend = sendMessageToBackend;
 exports.postAskQuestion = postAskQuestion;
 exports.getChatMessages = getChatMessages;
@@ -97,6 +100,51 @@ async function deleteMessage(options, messageId) {
     });
     return { success: true };
 }
+/**
+ * PATCH /api/v1/messages/:id — update the text of an existing message.
+ * Useful for status-updates-in-place (e.g. "Working..." → "Done"), replacing
+ * the prior approach of sending a new message every time.
+ */
+async function editMessageText(options, userId, messageId, text) {
+    const url = `${options.baseUrl.replace(/\/$/, '')}/api/v1/messages/${messageId}`;
+    return this.helpers.httpRequest({
+        method: 'PATCH',
+        url,
+        headers: buildHeaders(options.apiKey),
+        body: { userId, text },
+        json: true,
+    });
+}
+/**
+ * PATCH /api/v1/messages/:id/pin — toggle the pin state of a message.
+ * Body { isPinned: boolean }. Backend stamps pinned_at when true,
+ * clears it when false. Emits a message_pinned WebSocket event.
+ */
+async function setMessagePinned(options, messageId, isPinned) {
+    const url = `${options.baseUrl.replace(/\/$/, '')}/api/v1/messages/${messageId}/pin`;
+    return this.helpers.httpRequest({
+        method: 'PATCH',
+        url,
+        headers: buildHeaders(options.apiKey),
+        body: { isPinned },
+        json: true,
+    });
+}
+/**
+ * GET /api/v1/chats/:chatId?userId=... — fetch chat metadata (title,
+ * assistantId, ownership). Useful for AI agents that need context before
+ * deciding how to respond.
+ */
+async function getChat(options, chatId, userId) {
+    const qs = userId ? `?userId=${encodeURIComponent(userId)}` : '';
+    const url = `${options.baseUrl.replace(/\/$/, '')}/api/v1/chats/${chatId}${qs}`;
+    return this.helpers.httpRequest({
+        method: 'GET',
+        url,
+        headers: buildHeaders(options.apiKey),
+        json: true,
+    });
+}
 async function sendMessageToBackend(options, payload) {
     const url = `${options.baseUrl.replace(/\/$/, '')}/api/v1/send-message`;
     const body = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-bgos",
-  "version": "1.3.4",
+  "version": "1.4.1",
   "description": "n8n community nodes for BGOS (Brand Growth OS) - AI assistant chat platform",
   "keywords": [
     "n8n-community-node-package",