n8n-nodes-bgos 1.3.2 → 1.4.0

package/README.md

@@ -16,6 +16,37 @@ Perform operations on the BGOS platform:
 | **User** | Get or Create, Update |
 | **Scheduled Task** | Get, Get User Tasks, Delete |
 
+#### Render Mode — Inline Buttons vs. Modal Pop-Under
+
+Two ways the BGOS app renders buttons that come with a message:
+
+| Mode | Looks Like | When It Makes Sense |
+|---|---|---|
+| **Inline** (default on `sendMessage`) | Telegram-style chips inside a warm off-white card below the message. Skip (top-left), "✍ Custom reply" footer link. Stays clickable forever — user can answer now, tomorrow, or never. | The message is **not** a direct reply to something the user just typed: cron, scheduler, external webhook, unprompted check-in. Single question, up to 6 labeled choices. |
+| **Modal** (default on `askUserInput`) | Bottom sheet / pop-under that demands attention. Multi-question carousel, free-text fallback, skip-all. | Active back-and-forth conversation — user just sent a message and you need their answer to continue. Also use for multi-question flows. |
+
+**Default to inline unless you know the user is actively in the chat.** Modals interrupt. Inline never does.
+
+##### Decision tree for AI agents
+
+```
+Is this message triggered by a user message they sent in the last ~2 minutes?
+├─ YES → modal OK (but inline also works)
+└─ NO  → inline. Always.
+
+Do you need multi-question carousel, free-text, OR skip-all semantics?
+├─ YES → must use modal (askUserInput op with askRenderMode=modal)
+└─ NO  → prefer inline
+```
+
+##### Agent-facing contract
+
+- **Inline** chips ≤ 6 (backend rejects more). Labels ≤ 24 chars render cleanly; longer wraps.
+- When the user clicks a chip, your `BGOS Trigger` receives `button_clicked` with `callback_data` = the option's `value`.
+- When the user taps **Skip**, `button_clicked` fires with `callback_data: "__skip__"` and `option_id: null`.
+- When the user taps **Custom reply** and submits free text, they get **two** events: a normal user `message` AND a `button_clicked` with `callback_data: "__custom__"` + `custom_text: <what they typed>`. Correlate by `message_id`.
+- Respond to button clicks with the **Answer a Callback** operation so the chip animation completes.
+
 #### Ask User Input
 
 Pops the BGOS app's polished modal/sheet to ask the user 1–4 multiple-choice questions in a single carousel. Each question accepts: option list (label + value), optional free-text fallback, optional skip. The node POSTs each question to `/api/v1/messages` with `messageType=ask_user_input`, sharing one `askId` so they group into one carousel.

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 ──────────────────────────────────────────────
@@ -228,6 +253,17 @@ class BGOSAction {
                         placeholder: '[{"label":"Yes","value":"yes"},{"label":"No","value":"no"}]',
                         description: 'JSON array of button options to display with the message',
                     },
+                    {
+                        displayName: 'Render Mode',
+                        name: 'renderMode',
+                        type: 'options',
+                        default: 'inline',
+                        options: [
+                            { name: 'Inline buttons (Telegram-style, asynchronous)', value: 'inline' },
+                            { name: 'Modal pop-under (interactive, blocks UI)', value: 'modal' },
+                        ],
+                        description: 'Rule: If the message is NOT a direct reply to something the user just typed — cron, scheduler, external webhook, unprompted check-in — use INLINE. If the user just sent a message within the last ~2 min and you want their full attention, MODAL is acceptable. When in doubt, pick INLINE — it never interrupts. Max 6 options for inline.',
+                    },
                 ],
             },
             // ── Delete a Message ──────────────────────────────────────────────────
@@ -240,6 +276,115 @@ 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: 'User ID',
+                name: 'userId',
+                type: 'string',
+                default: '',
+                placeholder: 'user_xxx',
+                description: 'User ID who owns the chat — needed to poll its messages. Falls back to user_id / userId from input data.',
+                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: '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',
@@ -340,6 +485,18 @@ class BGOSAction {
                 description: 'Whether the node should block until every question is answered (or the timeout expires) and return structured answers. When disabled, the node returns immediately after posting; subscribe to the Ask Response event in a BGOS Trigger to receive each answer.',
                 displayOptions: { show: { resource: ['message'], operation: ['askUserInput'] } },
             },
+            {
+                displayName: 'Render Mode',
+                name: 'askRenderMode',
+                type: 'options',
+                default: 'modal',
+                options: [
+                    { name: 'Modal pop-under (interactive, blocks UI)', value: 'modal' },
+                    { name: 'Inline buttons (Telegram-style, asynchronous)', value: 'inline' },
+                ],
+                description: 'MODAL is the default because askUserInput is typically used mid-conversation. Switch to INLINE if this ask is triggered by cron/schedule/external webhook, or if you do NOT want to interrupt the user. Note: only MODAL supports multi-question carousel, free-text, and skip-all. INLINE renders 1 question with up to 6 chips plus a "Custom reply" / "Skip" footer.',
+                displayOptions: { show: { resource: ['message'], operation: ['askUserInput'] } },
+            },
             {
                 displayName: 'Additional Fields',
                 name: 'askAdditionalFields',
@@ -372,7 +529,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',
@@ -534,7 +691,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'],
@@ -569,14 +726,40 @@ class BGOSAction {
                     nodeParams.fileId = String(additionalFields.fileId ?? '');
                     nodeParams.sender = String(additionalFields.sender ?? 'assistant');
                     nodeParams.options = String(additionalFields.options ?? '');
+                    nodeParams.renderMode = additionalFields.renderMode
+                        ? String(additionalFields.renderMode)
+                        : 'inline';
                 }
                 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, '') ?? '');
+                    nodeParams.userId = String(this.getNodeParameter('userId', i, '') ?? '');
+                    const replyAdditional = this.getNodeParameter('replyAdditionalFields', i, {});
+                    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, '') ?? '');
                     nodeParams.waitForAnswers = Boolean(this.getNodeParameter('waitForAnswers', i, true));
+                    nodeParams.renderMode = String(this.getNodeParameter('askRenderMode', i, 'modal') ?? 'modal');
                     const askQuestionsRaw = this.getNodeParameter('askQuestions', i, {});
                     const questions = (askQuestionsRaw.question ?? []).map((q) => ({
                         text: String(q.text ?? '').trim(),

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

@@ -37,6 +37,10 @@ type NodeParams = {
     waitForAnswers?: boolean;
     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

@@ -50,6 +50,10 @@ async function handleEventByType(eventType, eventData, nodeParams) {
             else if (Array.isArray(eventData.options)) {
                 buttonOptions = eventData.options;
             }
+            const renderMode = (nodeParams.renderMode
+                ?? eventData.renderMode
+                ?? eventData.render_mode
+                ?? 'inline');
             return await techWebhook_1.sendMessageToBackend.call(this, apiOptions, {
                 assistantId: assistantId,
                 chatId: chatId,
@@ -57,6 +61,7 @@ async function handleEventByType(eventType, eventData, nodeParams) {
                 text,
                 options: buttonOptions,
                 files,
+                renderMode,
                 isCode: (eventData.isCode ?? message?.isCode ?? null),
                 artifactCode: (eventData.artifactCode ?? message?.artifactCode ?? null),
                 isArticle: (eventData.isArticle ?? message?.isArticle ?? null),
@@ -76,6 +81,80 @@ 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 ?? 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, User ID, and Text are required for Send and Wait for Reply.');
+            }
+            // Step 1: post the outgoing message and capture its id
+            const sendResult = (await techWebhook_1.sendMessageToBackend.call(this, apiOptions, {
+                assistantId: assistantId,
+                chatId: chatId,
+                sender: 'assistant',
+                text,
+            }));
+            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);
@@ -108,6 +187,10 @@ async function handleEventByType(eventType, eventData, nodeParams) {
                 if (!q.options.length)
                     throw new Error(`Question ${idx + 1}: at least one option is required.`);
             }
+            const renderMode = (nodeParams.renderMode
+                ?? eventData.renderMode
+                ?? eventData.render_mode
+                ?? 'modal');
             // Post each question. The first call's response carries the
             // backend-generated askId; reuse it for the rest so they group into
             // one carousel/sheet on the frontend.
@@ -124,6 +207,7 @@ async function handleEventByType(eventType, eventData, nodeParams) {
                     allowFreeText: q.allowFreeText,
                     allowSkip: q.allowSkip,
                     options: q.options,
+                    renderMode,
                 });
                 postedIds.push(posted.id);
                 if (!askId && posted.askId)
@@ -233,6 +317,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;
@@ -25,6 +43,7 @@ export declare function sendMessageToBackend(this: IExecuteFunctions, options: B
     text?: string | null;
     options?: unknown[];
     files?: unknown[];
+    renderMode?: string | null;
     isCode?: boolean | null;
     artifactCode?: string | null;
     isArticle?: boolean | null;
@@ -67,6 +86,7 @@ export declare function postAskQuestion(this: IExecuteFunctions, options: BgosAp
         label: string;
         value: string;
     }>;
+    renderMode?: string | null;
 }): Promise<AskQuestionPosted>;
 export interface ChatMessageEntry {
     message: {

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 = {
@@ -117,6 +165,8 @@ async function sendMessageToBackend(options, payload) {
         options: payload.options ?? [],
         files: payload.files ?? [],
     };
+    if (payload.renderMode)
+        body.renderMode = payload.renderMode;
     return this.helpers.httpRequest({
         method: 'POST',
         url,
@@ -148,6 +198,8 @@ async function postAskQuestion(options, payload) {
     };
     if (payload.askId)
         body.askId = payload.askId;
+    if (payload.renderMode)
+        body.renderMode = payload.renderMode;
     const result = (await this.helpers.httpRequest({
         method: 'POST',
         url,

package/package.json

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