n8n-nodes-bgos 1.4.3 → 1.6.0

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

@@ -46,6 +46,7 @@ class BGOSAction {
                     { name: 'Chat', value: 'chat' },
                     { name: 'File', value: 'file' },
                     { name: 'Message', value: 'message' },
+                    { name: 'Peer Agent', value: 'peer' },
                 ],
                 default: 'message',
             },
@@ -199,6 +200,123 @@ class BGOSAction {
                 default: 'answerCallback',
                 required: true,
             },
+            // ── Peer Agent operations ─────────────────────────────────────────────
+            {
+                displayName: 'Operation',
+                name: 'operation',
+                type: 'options',
+                noDataExpression: true,
+                displayOptions: { show: { resource: ['peer'] } },
+                options: [
+                    {
+                        name: 'List Peers',
+                        value: 'listPeers',
+                        description: "List the user's other assistants visible to this agent. Each peer carries `introduced` (true if you may message them right now) and `expiresAt` for ephemeral allow-once introductions.",
+                        action: 'List peers',
+                    },
+                    {
+                        name: 'Send to Peer',
+                        value: 'sendToPeer',
+                        description: "Send a message into another assistant's side-thread for the user. Optional waitForReply blocks (deadline polling) until the peer replies. Returns { status, sideThreadChatId, messageId, reply? }. Status='requires_introduction' means the user has not enabled this direction yet.",
+                        action: 'Send to peer',
+                    },
+                    {
+                        name: 'Mark Side-Thread Complete',
+                        value: 'markPeerThreadComplete',
+                        description: 'Write the one-line synthesis summary that flips the SideConversationCard from live to completed-collapsed. Only the chat-owner agent (the one whose primary chat hosts the parent message) may call this.',
+                        action: 'Mark side-thread complete',
+                    },
+                ],
+                default: 'listPeers',
+                required: true,
+            },
+            // ── Peer: parameters ──────────────────────────────────────────────────
+            {
+                displayName: 'Caller Assistant ID',
+                name: 'callerAssistantId',
+                type: 'string',
+                default: '',
+                placeholder: '820',
+                description: 'The assistant id of THIS agent (the one making the peer call). Required for all peer operations.',
+                displayOptions: { show: { resource: ['peer'] } },
+                required: true,
+            },
+            {
+                displayName: 'Target Assistant ID',
+                name: 'targetAssistantId',
+                type: 'string',
+                default: '',
+                placeholder: '821',
+                description: 'The assistant id of the peer being messaged.',
+                displayOptions: {
+                    show: { resource: ['peer'], operation: ['sendToPeer'] },
+                },
+                required: true,
+            },
+            {
+                displayName: 'Parent Message ID',
+                name: 'parentMessageId',
+                type: 'string',
+                default: '',
+                placeholder: '9991',
+                description: 'The message id in YOUR chat that anchors the side conversation. The frontend renders the SideConversationCard against this message.',
+                displayOptions: {
+                    show: {
+                        resource: ['peer'],
+                        operation: ['sendToPeer', 'markPeerThreadComplete'],
+                    },
+                },
+                required: true,
+            },
+            {
+                displayName: 'Text',
+                name: 'peerText',
+                type: 'string',
+                typeOptions: { rows: 4 },
+                default: '',
+                description: 'Message body to send to the peer.',
+                displayOptions: {
+                    show: { resource: ['peer'], operation: ['sendToPeer'] },
+                },
+                required: true,
+            },
+            {
+                displayName: 'Wait for Reply',
+                name: 'peerWaitForReply',
+                type: 'boolean',
+                default: false,
+                description: 'Block until the peer replies (their reply must include replyToId pointing to your sent message). Default: 60s timeout, max 600s.',
+                displayOptions: {
+                    show: { resource: ['peer'], operation: ['sendToPeer'] },
+                },
+            },
+            {
+                displayName: 'Timeout (Seconds)',
+                name: 'peerTimeoutSeconds',
+                type: 'number',
+                default: 60,
+                typeOptions: { minValue: 1, maxValue: 600 },
+                description: 'How long to wait for the peer reply.',
+                displayOptions: {
+                    show: {
+                        resource: ['peer'],
+                        operation: ['sendToPeer'],
+                        peerWaitForReply: [true],
+                    },
+                },
+            },
+            {
+                displayName: 'Summary',
+                name: 'peerSummary',
+                type: 'string',
+                default: '',
+                typeOptions: { rows: 3 },
+                description: 'One-line synthesis of what the peer accomplished. Shown to the user as the final state of the SideConversationCard.',
+                displayOptions: {
+                    show: { resource: ['peer'], operation: ['markPeerThreadComplete'] },
+                },
+                required: true,
+            },
             // ── Send a Message: required fields ───────────────────────────────────
             {
                 displayName: 'Assistant ID',
@@ -275,6 +393,66 @@ class BGOSAction {
                         ],
                         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.',
                     },
+                    {
+                        displayName: 'From Agent',
+                        name: 'fromAgent',
+                        type: 'collection',
+                        placeholder: 'Add Field',
+                        default: {},
+                        description: 'Set when this message is being sent BY ANOTHER AI AGENT (n8n LLM, external bot, peer BGOS agent) so it renders distinctly in the BGOS chat (cyan bubble + name+avatar header) and the receiving agent\'s webhook payload carries fromAgent + a systemHint telling its LLM "you are talking to another AI, not a human". Hybrid identity: registered peers (peerId or externalId looked up in agent_peers) win; otherwise inline name/color/avatarUrl are used as-is. Sender field stays USER — fromAgent is the third render flag.',
+                        options: [
+                            {
+                                displayName: 'Peer ID',
+                                name: 'peerId',
+                                type: 'number',
+                                default: 0,
+                                description: 'agent_peers.id from BGOS registry. If set, registry data wins over inline fields.',
+                            },
+                            {
+                                displayName: 'External ID',
+                                name: 'externalId',
+                                type: 'string',
+                                default: '',
+                                placeholder: 'marketing-agent-001',
+                                description: 'Stable string id (per BGOS user) used to look up the peer in the registry. Use when you registered the peer by name and don\'t want to track its numeric id.',
+                            },
+                            {
+                                displayName: 'Name',
+                                name: 'name',
+                                type: 'string',
+                                default: '',
+                                placeholder: 'Marketing Agent',
+                                description: 'Display name shown in the cyan bubble header. Inline fallback used when no registered peer matches.',
+                            },
+                            {
+                                displayName: 'Color',
+                                name: 'color',
+                                type: 'color',
+                                default: '',
+                                description: 'Bubble color hex (e.g. #0EA5E9). Inline fallback. Defaults to BGOS cyan when omitted.',
+                            },
+                            {
+                                displayName: 'Avatar URL',
+                                name: 'avatarUrl',
+                                type: 'string',
+                                default: '',
+                                placeholder: 'https://...',
+                                description: 'Avatar URL. Inline fallback.',
+                            },
+                            {
+                                displayName: 'Agent Type',
+                                name: 'type',
+                                type: 'options',
+                                default: 'n8n',
+                                options: [
+                                    { name: 'n8n workflow', value: 'n8n' },
+                                    { name: 'BGOS assistant', value: 'bgos' },
+                                    { name: 'External', value: 'external' },
+                                ],
+                                description: 'Origin of the agent. Influences the default systemHint sent to the receiving agent.',
+                            },
+                        ],
+                    },
                 ],
             },
             // ── Delete a Message ──────────────────────────────────────────────────
@@ -412,6 +590,66 @@ class BGOSAction {
                         default: 2000,
                         description: 'How often to check for new messages while waiting (default 2 seconds; minimum 1000).',
                     },
+                    {
+                        displayName: 'From Agent',
+                        name: 'fromAgent',
+                        type: 'collection',
+                        placeholder: 'Add Field',
+                        default: {},
+                        description: 'Identify the sending peer agent so the message renders distinctly (cyan bubble + header) AND the receiving agent\'s webhook payload includes fromAgent + a systemHint. Hybrid: registry (peerId/externalId) > inline (name/color/avatarUrl). The Send-and-Wait poll loop is unaffected — it still reads the next reply from the chat history regardless of fromAgent.',
+                        options: [
+                            {
+                                displayName: 'Peer ID',
+                                name: 'peerId',
+                                type: 'number',
+                                default: 0,
+                                description: 'agent_peers.id from BGOS registry. Registry wins over inline.',
+                            },
+                            {
+                                displayName: 'External ID',
+                                name: 'externalId',
+                                type: 'string',
+                                default: '',
+                                placeholder: 'marketing-agent-001',
+                                description: 'Stable string id used to look up the peer in the registry.',
+                            },
+                            {
+                                displayName: 'Name',
+                                name: 'name',
+                                type: 'string',
+                                default: '',
+                                placeholder: 'Marketing Agent',
+                                description: 'Display name. Inline fallback when no registry match.',
+                            },
+                            {
+                                displayName: 'Color',
+                                name: 'color',
+                                type: 'color',
+                                default: '',
+                                description: 'Bubble color hex e.g. #0EA5E9. Inline fallback.',
+                            },
+                            {
+                                displayName: 'Avatar URL',
+                                name: 'avatarUrl',
+                                type: 'string',
+                                default: '',
+                                placeholder: 'https://...',
+                                description: 'Avatar URL. Inline fallback.',
+                            },
+                            {
+                                displayName: 'Agent Type',
+                                name: 'type',
+                                type: 'options',
+                                default: 'n8n',
+                                options: [
+                                    { name: 'n8n workflow', value: 'n8n' },
+                                    { name: 'BGOS assistant', value: 'bgos' },
+                                    { name: 'External', value: 'external' },
+                                ],
+                                description: 'Origin of the agent.',
+                            },
+                        ],
+                    },
                 ],
             },
             // ── Ask User Input ────────────────────────────────────────────────────
@@ -758,6 +996,12 @@ class BGOSAction {
                     nodeParams.renderMode = additionalFields.renderMode
                         ? String(additionalFields.renderMode)
                         : 'inline';
+                    // Forward the From Agent collection block (peerId/externalId/
+                    // name/color/avatarUrl/type). Backend's hybrid resolver picks
+                    // registry > inline; absence falls through to a normal user msg.
+                    if (additionalFields.fromAgent && typeof additionalFields.fromAgent === 'object') {
+                        nodeParams.fromAgent = additionalFields.fromAgent;
+                    }
                 }
                 if (operation === 'deleteMessage') {
                     nodeParams.deleteMessageId = String(this.getNodeParameter('deleteMessageId', i, '') ?? '');
@@ -781,6 +1025,9 @@ class BGOSAction {
                     nodeParams.fileId = String(replyAdditional.fileId ?? '');
                     nodeParams.replyTimeoutSeconds = Number(replyAdditional.replyTimeoutSeconds ?? 600);
                     nodeParams.replyPollIntervalMs = Number(replyAdditional.replyPollIntervalMs ?? 2000);
+                    if (replyAdditional.fromAgent && typeof replyAdditional.fromAgent === 'object') {
+                        nodeParams.fromAgent = replyAdditional.fromAgent;
+                    }
                 }
                 if (operation === 'getChat') {
                     nodeParams.chatId = String(this.getNodeParameter('chatId', i, '') ?? '');

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

@@ -41,6 +41,13 @@ type NodeParams = {
     isPinned?: boolean;
     replyTimeoutSeconds?: number;
     replyPollIntervalMs?: number;
+    callerAssistantId?: string;
+    targetAssistantId?: string;
+    parentMessageId?: string;
+    peerText?: string;
+    peerWaitForReply?: boolean;
+    peerTimeoutSeconds?: number;
+    peerSummary?: string;
     [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

@@ -9,6 +9,38 @@ function getApiOptions(nodeParams) {
     }
     return { baseUrl, apiKey: nodeParams.apiKey };
 }
+/**
+ * Strip empty values from the `fromAgent` collection so an empty UI block
+ * doesn't accidentally trigger the agent-render path on the backend. Returns
+ * undefined when there's nothing meaningful to send.
+ */
+function sanitizeFromAgent(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const obj = raw;
+    const peerId = typeof obj.peerId === 'number' && obj.peerId > 0 ? obj.peerId : undefined;
+    const externalId = typeof obj.externalId === 'string' && obj.externalId.trim() ? obj.externalId.trim() : undefined;
+    const name = typeof obj.name === 'string' && obj.name.trim() ? obj.name.trim() : undefined;
+    const color = typeof obj.color === 'string' && obj.color.trim() ? obj.color.trim() : undefined;
+    const avatarUrl = typeof obj.avatarUrl === 'string' && obj.avatarUrl.trim() ? obj.avatarUrl.trim() : undefined;
+    const type = typeof obj.type === 'string' && obj.type.trim() ? obj.type.trim() : undefined;
+    if (!peerId && !externalId && !name && !color && !avatarUrl && !type)
+        return undefined;
+    const out = {};
+    if (peerId !== undefined)
+        out.peerId = peerId;
+    if (externalId !== undefined)
+        out.externalId = externalId;
+    if (name !== undefined)
+        out.name = name;
+    if (color !== undefined)
+        out.color = color;
+    if (avatarUrl !== undefined)
+        out.avatarUrl = avatarUrl;
+    if (type !== undefined)
+        out.type = type;
+    return out;
+}
 async function handleEventByType(eventType, eventData, nodeParams) {
     const operation = nodeParams.operation;
     const assistant = eventData.assistant;
@@ -54,6 +86,7 @@ async function handleEventByType(eventType, eventData, nodeParams) {
                 ?? eventData.renderMode
                 ?? eventData.render_mode
                 ?? 'inline');
+            const fromAgent = sanitizeFromAgent(nodeParams.fromAgent);
             return await techWebhook_1.sendMessageToBackend.call(this, apiOptions, {
                 assistantId: assistantId,
                 chatId: chatId,
@@ -71,6 +104,7 @@ async function handleEventByType(eventType, eventData, nodeParams) {
                 audioMimeType: (eventData.audioMimeType ?? message?.audioMimeType ?? null),
                 audioDuration: (eventData.audioDuration ?? message?.audioDuration ?? null),
                 isMixedAttachments: files.length > 0 && text ? true : (eventData.isMixedAttachments ?? message?.isMixedAttachments ?? null),
+                ...(fromAgent ? { fromAgent } : {}),
             });
         }
         case 'deleteMessage': {
@@ -115,7 +149,12 @@ async function handleEventByType(eventType, eventData, nodeParams) {
             const fileIdParam = nodeParams.fileId?.trim();
             const files = fileIdParam ? [{ id: fileIdParam }] : [];
             const sender = nodeParams.sender || 'assistant';
+            const fromAgentReply = sanitizeFromAgent(nodeParams.fromAgent);
             // Step 1: post the outgoing message and capture its id
+            // NOTE: fromAgent flows through here — it's persisted on the request
+            // message and forwarded on the receiving agent's webhook payload, but
+            // does NOT affect the polling loop below (which only reads sentMessageId
+            // and the next message's id+text).
             const sendResult = (await techWebhook_1.sendMessageToBackend.call(this, apiOptions, {
                 assistantId: assistantId,
                 chatId: chatId,
@@ -123,6 +162,7 @@ async function handleEventByType(eventType, eventData, nodeParams) {
                 text,
                 files,
                 isMixedAttachments: files.length > 0 ? true : null,
+                ...(fromAgentReply ? { fromAgent: fromAgentReply } : {}),
             }));
             const sentMessageId = Number(sendResult?.id
                 ?? sendResult?.message?.id
@@ -457,6 +497,64 @@ async function handleEventByType(eventType, eventData, nodeParams) {
                 error,
             });
         }
+        // ─────────────────────────────────────────────────────────────────────
+        // Peer Agent (cross-channel agent-to-agent) — see
+        // docs/superpowers/specs/2026-04-30-agent-to-agent-via-bgos-design.md
+        // ─────────────────────────────────────────────────────────────────────
+        case 'listPeers': {
+            const apiOptions = getApiOptions(nodeParams);
+            const callerAssistantIdRaw = nodeParams.callerAssistantId ??
+                eventData.assistant_id ??
+                assistant?.id;
+            const callerAssistantId = Number(callerAssistantIdRaw);
+            if (!Number.isFinite(callerAssistantId) || callerAssistantId <= 0) {
+                throw new Error('Caller Assistant ID is required for List Peers (the assistant id of THIS agent).');
+            }
+            return await techWebhook_1.listPeers.call(this, apiOptions, callerAssistantId);
+        }
+        case 'sendToPeer': {
+            const apiOptions = getApiOptions(nodeParams);
+            const callerAssistantId = Number(nodeParams.callerAssistantId);
+            const targetAssistantId = Number(nodeParams.targetAssistantId);
+            const parentMessageId = Number(nodeParams.parentMessageId);
+            const text = (nodeParams.peerText ?? '').trim();
+            if (!Number.isFinite(callerAssistantId) || callerAssistantId <= 0) {
+                throw new Error('Caller Assistant ID is required for Send to Peer.');
+            }
+            if (!Number.isFinite(targetAssistantId) || targetAssistantId <= 0) {
+                throw new Error('Target Assistant ID is required for Send to Peer.');
+            }
+            if (!Number.isFinite(parentMessageId) || parentMessageId <= 0) {
+                throw new Error('Parent Message ID is required for Send to Peer — it anchors the SideConversationCard in your chat.');
+            }
+            if (!text) {
+                throw new Error('Text is required for Send to Peer.');
+            }
+            return await techWebhook_1.sendToPeer.call(this, apiOptions, callerAssistantId, targetAssistantId, {
+                text,
+                parentMessageId,
+                waitForReply: nodeParams.peerWaitForReply === true,
+                timeoutSeconds: typeof nodeParams.peerTimeoutSeconds === 'number'
+                    ? nodeParams.peerTimeoutSeconds
+                    : undefined,
+            });
+        }
+        case 'markPeerThreadComplete': {
+            const apiOptions = getApiOptions(nodeParams);
+            const callerAssistantId = Number(nodeParams.callerAssistantId);
+            const parentMessageId = Number(nodeParams.parentMessageId);
+            const summary = (nodeParams.peerSummary ?? '').trim();
+            if (!Number.isFinite(callerAssistantId) || callerAssistantId <= 0) {
+                throw new Error('Caller Assistant ID is required for Mark Side-Thread Complete.');
+            }
+            if (!Number.isFinite(parentMessageId) || parentMessageId <= 0) {
+                throw new Error('Parent Message ID is required for Mark Side-Thread Complete.');
+            }
+            if (!summary) {
+                throw new Error('Summary is required for Mark Side-Thread Complete — this is the one-line synthesis the user sees in the SideConversationCard.');
+            }
+            return await techWebhook_1.markPeerThreadComplete.call(this, apiOptions, callerAssistantId, parentMessageId, summary);
+        }
         default:
             throw new Error(`Unsupported operation: ${operation}`);
     }

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

@@ -146,3 +146,31 @@ export declare function uploadBinaryToS3(this: IExecuteFunctions, uploadUrl: str
  * Step 3: Save file metadata to the BGOS backend after a successful S3 upload.
  */
 export declare function saveFileMeta(this: IExecuteFunctions, options: BgosApiOptions, userId: string, key: string, type: string, size: number): Promise<FileUploadResult>;
+export interface PeerListItem {
+    assistantId: number;
+    name: string;
+    avatarUrl: string | null;
+    color: string | null;
+    introduced: boolean;
+    expiresAt: string | null;
+}
+export interface SendToPeerResult {
+    status: 'sent' | 'requires_introduction';
+    sideThreadChatId: number | null;
+    messageId: number | null;
+    reply: {
+        messageId: number;
+        text: string | null;
+        fromAssistantId: number;
+    } | null;
+}
+export declare function listPeers(this: IExecuteFunctions, options: BgosApiOptions, callerAssistantId: number): Promise<PeerListItem[]>;
+export declare function sendToPeer(this: IExecuteFunctions, options: BgosApiOptions, callerAssistantId: number, targetAssistantId: number, body: {
+    text: string;
+    parentMessageId: number;
+    waitForReply?: boolean;
+    timeoutSeconds?: number;
+}): Promise<SendToPeerResult>;
+export declare function markPeerThreadComplete(this: IExecuteFunctions, options: BgosApiOptions, callerAssistantId: number, parentMessageId: number, summary: string): Promise<{
+    ok: true;
+}>;

package/dist/nodes/BGOSAction/techWebhook.js

@@ -17,6 +17,9 @@ exports.reportCallbackResult = reportCallbackResult;
 exports.getUploadUrl = getUploadUrl;
 exports.uploadBinaryToS3 = uploadBinaryToS3;
 exports.saveFileMeta = saveFileMeta;
+exports.listPeers = listPeers;
+exports.sendToPeer = sendToPeer;
+exports.markPeerThreadComplete = markPeerThreadComplete;
 function buildHeaders(apiKey) {
     const headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
     if (apiKey)
@@ -167,6 +170,12 @@ async function sendMessageToBackend(options, payload) {
     };
     if (payload.renderMode)
         body.renderMode = payload.renderMode;
+    // Forward the peer-agent identity block when the workflow set it. Backend's
+    // hybrid resolver picks registry vs inline; either form makes the BGOS UI
+    // render the cyan agent bubble + name header on this message.
+    if (payload.fromAgent && typeof payload.fromAgent === 'object') {
+        body.fromAgent = payload.fromAgent;
+    }
     return this.helpers.httpRequest({
         method: 'POST',
         url,
@@ -283,3 +292,38 @@ async function saveFileMeta(options, userId, key, type, size) {
         json: true,
     });
 }
+function buildPeerHeaders(apiKey, callerAssistantId) {
+    const headers = buildHeaders(apiKey);
+    headers['X-Caller-Assistant-Id'] = String(callerAssistantId);
+    return headers;
+}
+async function listPeers(options, callerAssistantId) {
+    const url = `${options.baseUrl.replace(/\/$/, '')}/api/v1/peers`;
+    const result = (await this.helpers.httpRequest({
+        method: 'GET',
+        url,
+        headers: buildPeerHeaders(options.apiKey, callerAssistantId),
+        json: true,
+    }));
+    return Array.isArray(result) ? result : [];
+}
+async function sendToPeer(options, callerAssistantId, targetAssistantId, body) {
+    const url = `${options.baseUrl.replace(/\/$/, '')}/api/v1/peers/${encodeURIComponent(String(targetAssistantId))}/send`;
+    return this.helpers.httpRequest({
+        method: 'POST',
+        url,
+        headers: buildPeerHeaders(options.apiKey, callerAssistantId),
+        body,
+        json: true,
+    });
+}
+async function markPeerThreadComplete(options, callerAssistantId, parentMessageId, summary) {
+    const url = `${options.baseUrl.replace(/\/$/, '')}/api/v1/peers/threads/${encodeURIComponent(String(parentMessageId))}/complete`;
+    return this.helpers.httpRequest({
+        method: 'POST',
+        url,
+        headers: buildPeerHeaders(options.apiKey, callerAssistantId),
+        body: { summary },
+        json: true,
+    });
+}

package/dist/nodes/BgosTrigger/BgosTrigger.node.js

@@ -133,8 +133,46 @@ class BgosTrigger {
         const rawBody = this.getBodyData();
         const updates = this.getNodeParameter('updates', 0);
         const workflowId = String(this.getWorkflow().id ?? 'default');
-        if (isRateLimited(workflowId))
-            return { workflowData: [] };
+        if (isRateLimited(workflowId)) {
+            // Drop the event explicitly with HTTP 429 so the upstream caller
+            // (BGOS backend webhook forwarder) sees a real failure and surfaces
+            // it in the BGOS forwarder log. Returning empty workflowData with a
+            // 200 silently swallowed flood-control drops, which made it
+            // impossible to diagnose missing events from a noisy assistant.
+            const res = this.getResponseObject();
+            try {
+                res.status(429).json({
+                    error: 'rate_limited',
+                    message: 'BGOS Trigger rate limit exceeded — event dropped.',
+                    workflowId,
+                    windowMs: RATE_WINDOW_MS,
+                    maxEvents: RATE_MAX_EVENTS,
+                });
+            }
+            catch {
+                // Older n8n runtimes lack getResponseObject — fall back to the
+                // older shape but still expose the drop in workflowData so users
+                // can branch on it instead of silently no-op'ing.
+            }
+            return {
+                webhookResponse: {
+                    status: 429,
+                    body: 'rate_limited',
+                },
+                workflowData: [
+                    [
+                        {
+                            json: {
+                                error: 'rate_limited',
+                                workflowId,
+                                windowMs: RATE_WINDOW_MS,
+                                maxEvents: RATE_MAX_EVENTS,
+                            },
+                        },
+                    ],
+                ],
+            };
+        }
         if (!rawBody) {
             return { workflowData: [] };
         }

package/dist/package.json

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

package/package.json

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