n8n-nodes-bgos 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BrandGrowthOS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BGOS Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# n8n-nodes-bgos
+
+Community nodes for [n8n](https://n8n.io/) to integrate with the [BGOS](https://brandgrowthos.ai) AI assistant chat platform.
+
+## Nodes
+
+### BGOS (Action Node)
+
+Perform operations on the BGOS platform:
+
+| Resource | Operations |
+|---|---|
+| **Message** | Send Message, Create, Bulk Create, Edit, Delete, Button Callback |
+| **Chat** | Create, Get, Rename, Delete, Get Messages, Get Unread, Increment Unread, Mark as Read |
+| **Assistant** | Create, Get, Update, Delete, Reorder, Get With Chats |
+| **User** | Get or Create, Update |
+| **Scheduled Task** | Get, Get User Tasks, Delete |
+
+### BGOS Trigger (Webhook Node)
+
+Starts workflows when BGOS events occur. Supports 16 event types:
+
+- `message`, `edited_message`, `voice_message`, `reply_message`
+- `new_chat`, `chat_renamed`, `chat_deleted`
+- `new_assistant`, `assistant_updated`, `assistant_deleted`
+- `voice_started`, `voice_ended`
+- `message_deleted`, `button_clicked`
+- `user_created`, `user_updated`
+
+## Credentials
+
+Configure with your BGOS backend URL and optional API key:
+
+- **Base URL**: Your BGOS backend URL (default: `http://localhost:8080`)
+- **API Key**: Optional, for future authentication support
+
+## Setup
+
+### In BGOS Backend
+
+Set the `FORWARDER_WEBHOOK_URL` environment variable to your n8n webhook URL:
+
+```
+FORWARDER_WEBHOOK_URL=https://your-n8n-instance.com/webhook/bgos-webhook
+```
+
+### In n8n
+
+1. Install the package: `pnpm install n8n-nodes-bgos`
+2. Configure BGOS API credentials with your backend URL
+3. Use the BGOS Trigger node to receive events
+4. Use the BGOS node to perform actions
+
+## Development
+
+```bash
+pnpm install
+pnpm build
+```
+
+## License
+
+[MIT](LICENSE.md)

package/dist/credentials/BgosApi.credentials.d.ts

@@ -0,0 +1,9 @@
+import { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class BgosApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/BgosApi.credentials.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BgosApi = void 0;
+class BgosApi {
+    name = 'bgosApi';
+    displayName = 'BGOS API';
+    documentationUrl = '';
+    properties = [
+        {
+            displayName: 'Base URL',
+            name: 'baseUrl',
+            type: 'string',
+            default: 'http://localhost:8080',
+            required: true,
+            description: 'The base URL of your BGOS backend',
+        },
+        {
+            displayName: 'API Key',
+            name: 'apiKey',
+            type: 'string',
+            typeOptions: { password: true },
+            default: '',
+            description: 'API key for authentication (optional, for future use)',
+        },
+    ];
+    authenticate = {
+        type: 'generic',
+        properties: {
+            headers: {
+                Authorization: '={{"Bearer " + $credentials.apiKey}}',
+            },
+        },
+    };
+    test = {
+        request: {
+            baseURL: '={{$credentials.baseUrl}}',
+            url: '/api/v1/service-options/health',
+            method: 'GET',
+        },
+    };
+}
+exports.BgosApi = BgosApi;

package/dist/icons/bgos.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" width="32" height="32">
+  <circle cx="16" cy="16" r="16" fill="#262624"/>
+  <path d="M7 10C7 8.34315 8.34315 7 10 7H22C23.6569 7 25 8.34315 25 10V18C25 19.6569 23.6569 21 22 21H18L13 25V21H10C8.34315 21 7 19.6569 7 18V10Z" fill="#FFD900"/>
+  <text x="16" y="17.5" text-anchor="middle" font-family="Arial, sans-serif" font-weight="bold" font-size="10" fill="#262624">B</text>
+</svg>

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

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

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

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BGOSAction = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const eventHandler_1 = require("./handler/eventHandler");
+class BGOSAction {
+    description = {
+        displayName: 'BGOS Action',
+        name: 'bgosAction',
+        icon: 'file:../../icons/bgos.png',
+        group: ['transform'],
+        version: 1,
+        subtitle: '={{$parameter["operation"]}}',
+        description: 'Process BGOS events',
+        defaults: { name: 'BGOS Action' },
+        inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+        outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+        credentials: [
+            {
+                name: 'bgosApi',
+                required: false,
+                displayOptions: {
+                    show: {
+                        operation: [
+                            'sendMessageBackend',
+                            'reportCallbackResult',
+                            'createAssistant',
+                            'updateAssistant',
+                            'deleteAssistant',
+                            'renameChat',
+                            'deleteChat',
+                            'saveChatHistory',
+                        ],
+                    },
+                },
+            },
+        ],
+        properties: [
+            {
+                displayName: 'Operation',
+                name: 'operation',
+                type: 'options',
+                noDataExpression: true,
+                options: [
+                    { name: 'Send Message to Agent', value: 'sendMessage', description: 'Send message event to Agent webhook (Ava)' },
+                    { name: 'Send Message to BGOS', value: 'sendMessageBackend', description: 'Send message to BGOS backend API (POST /api/v1/send-message)' },
+                    { name: 'Send Voice Message to BGOS', value: 'sendVoiceMessageBackend', description: 'Send voice message to BGOS backend API' },
+                    { name: 'Send File to BGOS', value: 'sendFileMessageBackend', description: 'Send file attachment(s) to BGOS backend API' },
+                    { name: 'Send Code Artifact to BGOS', value: 'sendCodeArtifactBackend', description: 'Send code artifact to BGOS backend API' },
+                    { name: 'Send Article to BGOS', value: 'sendArticleBackend', description: 'Send long-form article to BGOS backend API' },
+                    { name: 'Report Callback Result', value: 'reportCallbackResult', description: 'Report success/error after processing button click' },
+                    { name: 'Create Assistant', value: 'createAssistant', description: 'Create assistant via BGOS backend API' },
+                    { name: 'Update Assistant', value: 'updateAssistant', description: 'Update assistant via BGOS backend API' },
+                    { name: 'Delete Assistant', value: 'deleteAssistant', description: 'Delete assistant via BGOS backend API' },
+                    { name: 'Rename Chat', value: 'renameChat', description: 'Rename chat via BGOS backend API' },
+                    { name: 'Delete Chat', value: 'deleteChat', description: 'Delete chat via BGOS backend API' },
+                    { name: 'Save Chat History', value: 'saveChatHistory', description: 'Save messages via BGOS backend API (POST /messages/bulk)' },
+                ],
+                default: 'sendMessage',
+                required: true,
+                description: 'Select operation to perform',
+            },
+            {
+                displayName: 'Assistant Webhook URL',
+                name: 'webhookUrl',
+                type: 'string',
+                default: '',
+                placeholder: 'https://n8n.example.com/webhook/ava',
+                description: 'Override assistant webhook URL for Send Message to Agent. If empty, uses webhook from trigger event.',
+                displayOptions: { show: { operation: ['sendMessage'] } },
+            },
+            {
+                displayName: 'User ID',
+                name: 'userId',
+                type: 'string',
+                default: '',
+                placeholder: 'user_xxx',
+                description: 'Override user ID. If empty, uses user_id from trigger event.',
+            },
+            {
+                displayName: 'Callback Success',
+                name: 'callbackSuccess',
+                type: 'boolean',
+                default: true,
+                description: 'Set to false to report an error.',
+                displayOptions: { show: { operation: ['reportCallbackResult'] } },
+            },
+            {
+                displayName: 'Callback Error Message',
+                name: 'callbackError',
+                type: 'string',
+                default: '',
+                placeholder: 'Optional error message when success is false',
+                displayOptions: { show: { operation: ['reportCallbackResult'] } },
+            },
+        ],
+    };
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i += 1) {
+            const operation = this.getNodeParameter('operation', i);
+            try {
+                const eventData = items[i].json;
+                const rawEventType = eventData.event_type;
+                const eventType = typeof rawEventType === 'string' ? rawEventType : String(rawEventType ?? '');
+                if (!eventType)
+                    throw new Error('Event type (event_type) is required in input data');
+                const creds = (await this.getCredentials('bgosApi'));
+                const apiBaseUrl = creds?.baseUrl ?? creds?.apiUrl ?? '';
+                const nodeParams = {
+                    operation,
+                    webhookUrl: String(this.getNodeParameter('webhookUrl', i, '') ?? ''),
+                    userId: String(this.getNodeParameter('userId', i, '') ?? ''),
+                    apiBaseUrl,
+                    apiKey: creds?.apiKey ?? '',
+                    callbackSuccess: Boolean(this.getNodeParameter('callbackSuccess', i, true)),
+                    callbackError: String(this.getNodeParameter('callbackError', i, '') ?? ''),
+                };
+                const result = await (0, eventHandler_1.handleEventByType)(eventType, eventData, nodeParams);
+                returnData.push({
+                    json: {
+                        ...items[i].json,
+                        ...result,
+                    },
+                });
+            }
+            catch (error) {
+                returnData.push({
+                    json: {
+                        ...items[i].json,
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.BGOSAction = BGOSAction;

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

@@ -0,0 +1,21 @@
+/**
+ * Event types — aligned with bgos-backend EventType (event.types.ts)
+ */
+export declare enum EventType {
+    MESSAGE = "message",
+    EDITED_MESSAGE = "edited_message",
+    VOICE_MESSAGE = "voice_message",
+    NEW_CHAT = "new_chat",
+    CHAT_RENAMED = "chat_renamed",
+    NEW_ASSISTANT = "new_assistant",
+    VOICE_STARTED = "voice_started",
+    VOICE_ENDED = "voice_ended",
+    REPLY_MESSAGE = "reply_message",
+    MESSAGE_DELETED = "message_deleted",
+    CHAT_DELETED = "chat_deleted",
+    ASSISTANT_UPDATED = "assistant_updated",
+    ASSISTANT_DELETED = "assistant_deleted",
+    USER_CREATED = "user_created",
+    USER_UPDATED = "user_updated",
+    BUTTON_CLICKED = "button_clicked"
+}

package/dist/nodes/BGOSAction/EventTypes.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventType = void 0;
+/**
+ * Event types — aligned with bgos-backend EventType (event.types.ts)
+ */
+var EventType;
+(function (EventType) {
+    EventType["MESSAGE"] = "message";
+    EventType["EDITED_MESSAGE"] = "edited_message";
+    EventType["VOICE_MESSAGE"] = "voice_message";
+    EventType["NEW_CHAT"] = "new_chat";
+    EventType["CHAT_RENAMED"] = "chat_renamed";
+    EventType["NEW_ASSISTANT"] = "new_assistant";
+    EventType["VOICE_STARTED"] = "voice_started";
+    EventType["VOICE_ENDED"] = "voice_ended";
+    EventType["REPLY_MESSAGE"] = "reply_message";
+    EventType["MESSAGE_DELETED"] = "message_deleted";
+    EventType["CHAT_DELETED"] = "chat_deleted";
+    EventType["ASSISTANT_UPDATED"] = "assistant_updated";
+    EventType["ASSISTANT_DELETED"] = "assistant_deleted";
+    EventType["USER_CREATED"] = "user_created";
+    EventType["USER_UPDATED"] = "user_updated";
+    EventType["BUTTON_CLICKED"] = "button_clicked";
+})(EventType || (exports.EventType = EventType = {}));

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

@@ -0,0 +1 @@
+export declare function sendMessageToAgent(webhookUrl: string, userId: string, messageData: Record<string, unknown>): Promise<unknown>;

package/dist/nodes/BGOSAction/agentWebhook.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendMessageToAgent = sendMessageToAgent;
+const form_data_1 = __importDefault(require("form-data"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const rateLimiter_1 = require("./rateLimiter");
+const http_status_codes_1 = require("http-status-codes");
+async function sendMessageToAgent(webhookUrl, userId, messageData) {
+    const url = `${webhookUrl}/${userId}`;
+    const formData = new form_data_1.default();
+    const msg = messageData.message;
+    if (messageData.chat_id)
+        formData.append('chatId', String(messageData.chat_id));
+    if (msg?.chatId)
+        formData.append('chatId', String(msg.chatId));
+    formData.append('sender', msg?.sender ?? 'user');
+    formData.append('sentDate', msg?.sentDate ?? new Date().toISOString());
+    if (messageData.text)
+        formData.append('text', String(messageData.text));
+    if (msg?.text)
+        formData.append('text', String(msg.text));
+    formData.append('isAudio', String(msg?.isAudio ?? false));
+    formData.append('hasAttachment', String(msg?.hasAttachment ?? false));
+    formData.append('duration', String(msg?.duration ?? 0));
+    formData.append('isMixedAttachments', String(msg?.isMixedAttachments ?? false));
+    if (msg?.audioFileName) {
+        formData.append('audioFileName', String(msg.audioFileName));
+        if (msg.audioData)
+            formData.append('audioData', String(msg.audioData));
+        if (msg.audioMimeType)
+            formData.append('audioMimeType', String(msg.audioMimeType));
+    }
+    if (msg?.files && Array.isArray(msg.files))
+        formData.append('files', JSON.stringify(msg.files));
+    const response = await (0, rateLimiter_1.rateLimitedRequest)(async () => {
+        const res = await (0, node_fetch_1.default)(url, {
+            method: 'POST',
+            body: formData,
+            headers: { 'User-Agent': 'n8n-BGOS-Action/1.0' },
+        });
+        if (res.status === http_status_codes_1.StatusCodes.TOO_MANY_REQUESTS) {
+            const retryAfter = res.headers.get('retry-after');
+            const delay = retryAfter ? parseInt(retryAfter, 10) * 1000 : 1000;
+            throw Object.assign(new Error(`Rate limit exceeded. Retry after ${delay}ms`), { response: res, status: http_status_codes_1.StatusCodes.TOO_MANY_REQUESTS });
+        }
+        return res;
+    });
+    if (!response.ok && response.status !== http_status_codes_1.StatusCodes.TOO_MANY_REQUESTS) {
+        throw new Error(`HTTP error! status: ${response.status} - ${response.statusText}`);
+    }
+    const contentType = response.headers.get('content-type');
+    const isAudioResponse = contentType && (contentType.includes('audio/') || contentType.includes('application/octet-stream') || contentType.includes('binary'));
+    if (isAudioResponse) {
+        const arrayBuffer = await response.arrayBuffer();
+        const base64Audio = Buffer.from(arrayBuffer).toString('base64');
+        return { type: 'audio', data: base64Audio, contentType, audioFileName: `audio_response_${Date.now()}.mp3` };
+    }
+    const responseText = await response.text();
+    if (!responseText) {
+        return { id: '-1', chat_id: messageData.chat_id ?? msg?.chatId, sender: 'assistant', sent_date: new Date().toISOString(), text: 'Empty response from server', is_audio: false, has_attachment: false };
+    }
+    return JSON.parse(responseText);
+}

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

@@ -0,0 +1,12 @@
+type NodeParams = {
+    operation: string;
+    webhookUrl?: string;
+    userId?: string;
+    apiBaseUrl?: string;
+    apiKey?: string;
+    callbackSuccess?: boolean;
+    callbackError?: string;
+    [key: string]: unknown;
+};
+export declare function handleEventByType(eventType: string, eventData: Record<string, unknown>, nodeParams: NodeParams): Promise<unknown>;
+export {};

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

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleEventByType = handleEventByType;
+const EventTypes_1 = require("../EventTypes");
+const agentWebhook_1 = require("../agentWebhook");
+const techWebhook_1 = require("../techWebhook");
+function getApiOptions(nodeParams) {
+    const baseUrl = nodeParams.apiBaseUrl?.trim();
+    if (!baseUrl) {
+        throw new Error('BGOS API base URL is required for this operation. Add BGOS API credentials to the node.');
+    }
+    return { baseUrl, apiKey: nodeParams.apiKey };
+}
+async function handleEventByType(eventType, eventData, nodeParams) {
+    const operation = nodeParams.operation;
+    const assistant = eventData.assistant;
+    const chat = eventData.chat;
+    const message = eventData.message;
+    switch (operation) {
+        case 'sendMessage': {
+            const userId = (nodeParams.userId ?? eventData.user_id ?? eventData.userId);
+            if (!userId)
+                throw new Error('User ID is required. We take it from the node parameters or from the event');
+            if (eventType !== EventTypes_1.EventType.MESSAGE && eventType !== EventTypes_1.EventType.EDITED_MESSAGE && eventType !== EventTypes_1.EventType.VOICE_MESSAGE && eventType !== EventTypes_1.EventType.REPLY_MESSAGE) {
+                throw new Error(`Operation 'sendMessage' can only be used with message events. Current event type: ${eventType}`);
+            }
+            const webhookUrl = (nodeParams.webhookUrl ?? assistant?.webhookUrl ?? assistant?.webhook);
+            if (!webhookUrl)
+                throw new Error('Webhook URL is required.');
+            return await (0, agentWebhook_1.sendMessageToAgent)(webhookUrl, userId, eventData);
+        }
+        case 'reportCallbackResult': {
+            const apiOptions = getApiOptions(nodeParams);
+            const messageId = eventData.message_id ?? eventData.messageId;
+            const optionId = eventData.option_id ?? eventData.optionId;
+            const userId = (nodeParams.userId ?? eventData.user_id ?? eventData.userId);
+            const success = nodeParams.callbackSuccess !== false;
+            const error = (nodeParams.callbackError ?? eventData.error);
+            if (!messageId || !optionId || !userId)
+                throw new Error('message_id, option_id and user_id are required for reportCallbackResult. Use data from button_clicked event.');
+            return await (0, techWebhook_1.reportCallbackResult)(apiOptions, { messageId: String(messageId), optionId: String(optionId), userId, success, error });
+        }
+        case 'sendMessageBackend':
+        case 'sendVoiceMessageBackend':
+        case 'sendFileMessageBackend':
+        case 'sendCodeArtifactBackend':
+        case 'sendArticleBackend': {
+            const apiOptions = getApiOptions(nodeParams);
+            const assistantId = eventData.assistantId ?? eventData.assistant_id ?? assistant?.id;
+            const chatId = eventData.chatId ?? eventData.chat_id ?? chat?.id ?? message?.chatId;
+            const text = eventData.text ?? message?.text ?? null;
+            if (!assistantId || !chatId)
+                throw new Error('assistantId and chatId are required for send-message operations.');
+            return await (0, techWebhook_1.sendMessageToBackend)(apiOptions, {
+                assistantId: assistantId,
+                chatId: chatId,
+                sender: (eventData.sender ?? message?.sender ?? 'assistant'),
+                text: text,
+                options: (eventData.options ?? eventData.messageOptions ?? []),
+                files: (eventData.files ?? eventData.messageFiles ?? []),
+                isCode: (eventData.isCode ?? message?.isCode ?? null),
+                artifactCode: (eventData.artifactCode ?? message?.artifactCode ?? null),
+                isArticle: (eventData.isArticle ?? message?.isArticle ?? null),
+                articleText: (eventData.articleText ?? message?.articleText ?? null),
+                isAudioMessage: (eventData.isAudioMessage ?? message?.isAudioMessage ?? null),
+                audioData: (eventData.audioData ?? message?.audioData ?? null),
+                audioMimeType: (eventData.audioMimeType ?? message?.audioMimeType ?? null),
+                audioDuration: (eventData.audioDuration ?? message?.audioDuration ?? null),
+                isMixedAttachments: (eventData.isMixedAttachments ?? message?.isMixedAttachments ?? null),
+            });
+        }
+        case 'createAssistant': {
+            const userId = (nodeParams.userId ?? eventData.user_id ?? eventData.userId);
+            if (!userId)
+                throw new Error('User ID is required.');
+            if (eventType !== EventTypes_1.EventType.NEW_ASSISTANT)
+                throw new Error(`Operation 'createAssistant' can only be used with NEW_ASSISTANT event. Current event type: ${eventType}`);
+            if (!assistant)
+                throw new Error('Assistant data is required for createAssistant operation.');
+            const { id: _id, userId: _u, ...assistantData } = assistant;
+            return await (0, techWebhook_1.createAssistant)(getApiOptions(nodeParams), userId, assistantData);
+        }
+        case 'updateAssistant': {
+            const userId = (nodeParams.userId ?? eventData.user_id ?? eventData.userId);
+            if (!userId)
+                throw new Error('User ID is required.');
+            if (!assistant)
+                throw new Error('Assistant data is required for updateAssistant operation.');
+            const assistantId = eventData.assistant_id ?? assistant?.id;
+            if (!assistantId)
+                throw new Error('Assistant ID is required for updateAssistant operation.');
+            const { id: _id, userId: _u, ...assistantData } = assistant;
+            return await (0, techWebhook_1.updateAssistant)(getApiOptions(nodeParams), userId, String(assistantId), assistantData);
+        }
+        case 'deleteAssistant': {
+            const userId = (nodeParams.userId ?? eventData.user_id ?? eventData.userId);
+            if (!userId)
+                throw new Error('User ID is required.');
+            const assistantId = eventData.assistant_id ?? assistant?.id;
+            if (!assistantId)
+                throw new Error('Assistant ID is required for deleteAssistant operation.');
+            return await (0, techWebhook_1.deleteAssistant)(getApiOptions(nodeParams), userId, String(assistantId));
+        }
+        case 'renameChat': {
+            const userId = (nodeParams.userId ?? eventData.user_id ?? eventData.userId);
+            if (!userId)
+                throw new Error('User ID is required.');
+            if (eventType !== EventTypes_1.EventType.CHAT_RENAMED)
+                throw new Error(`Operation 'renameChat' can only be used with CHAT_RENAMED event. Current event type: ${eventType}`);
+            const chatId = eventData.chat_id ?? chat?.id;
+            const newName = eventData.new_name ?? chat?.title;
+            if (!chatId || !newName)
+                throw new Error('Chat ID and new name are required for renameChat operation.');
+            return await (0, techWebhook_1.renameChat)(getApiOptions(nodeParams), userId, String(chatId), String(newName));
+        }
+        case 'deleteChat': {
+            const userId = (nodeParams.userId ?? eventData.user_id ?? eventData.userId);
+            if (!userId)
+                throw new Error('User ID is required.');
+            const chatId = eventData.chat_id ?? chat?.id;
+            if (!chatId)
+                throw new Error('Chat ID is required for deleteChat operation.');
+            return await (0, techWebhook_1.deleteChat)(getApiOptions(nodeParams), userId, String(chatId));
+        }
+        case 'saveChatHistory': {
+            const userId = (nodeParams.userId ?? eventData.user_id ?? eventData.userId);
+            if (!userId)
+                throw new Error('User ID is required.');
+            if (!eventData.message && !eventData.messages)
+                throw new Error('Message or messages data is required for saveChatHistory operation.');
+            const messages = (eventData.messages ?? [eventData.message]);
+            return await (0, techWebhook_1.saveChatHistory)(getApiOptions(nodeParams), userId, messages);
+        }
+        default:
+            throw new Error(`Unsupported operation: ${operation}`);
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare function retryWithBackoff<T>(fn: () => Promise<T>, maxRetries?: number, retryCount?: number): Promise<T>;
+export declare function rateLimitedRequest<T>(fn: () => Promise<T>): Promise<T>;

package/dist/nodes/BGOSAction/rateLimiter.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryWithBackoff = retryWithBackoff;
+exports.rateLimitedRequest = rateLimitedRequest;
+const bottleneck_1 = __importDefault(require("bottleneck"));
+const http_status_codes_1 = require("http-status-codes");
+const limiter = new bottleneck_1.default({
+    reservoir: 30,
+    reservoirRefreshAmount: 30,
+    reservoirRefreshInterval: 1000,
+    maxConcurrent: 1,
+    minTime: 1000 / 30,
+});
+async function retryWithBackoff(fn, maxRetries = 5, retryCount = 0) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        const err = error;
+        const status = err?.response?.status ?? err?.status;
+        const isRateLimitError = status === http_status_codes_1.StatusCodes.TOO_MANY_REQUESTS ||
+            (err?.message && String(err.message).includes(String(http_status_codes_1.StatusCodes.TOO_MANY_REQUESTS)));
+        if (isRateLimitError && retryCount < maxRetries) {
+            const retryAfter = err?.response?.headers?.get?.('retry-after');
+            const delay = retryAfter ? parseInt(retryAfter, 10) * 1000 : Math.min(1000 * 2 ** retryCount, 32000);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            return retryWithBackoff(fn, maxRetries, retryCount + 1);
+        }
+        throw error;
+    }
+}
+async function rateLimitedRequest(fn) {
+    return limiter.schedule(() => retryWithBackoff(fn));
+}