n8n-nodes-chat-data 1.0.0

package/dist/nodes/ChatData/ChatData.node.js

@@ -0,0 +1,980 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatData = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ActionDescription_1 = require("./ActionDescription");
+const ChatbotDescription_1 = require("./ChatbotDescription");
+const TriggerDescription_1 = require("./TriggerDescription");
+class ChatData {
+    constructor() {
+        this.description = {
+            displayName: 'Chat Data',
+            name: 'chatData',
+            group: ['transform'],
+            version: 1,
+            description: 'Basic Chat Data Node',
+            defaults: {
+                name: 'Chat Data',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            icon: 'file:ChatData.svg',
+            subtitle: '={{$parameter["resource"] + ": " + $parameter["operation"]}}',
+            credentials: [
+                {
+                    name: 'chatDataApi',
+                    required: true,
+                },
+            ],
+            requestDefaults: {
+                baseURL: '{{$credentials.baseUrl}}',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+            },
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: 'onReceived',
+                    path: 'webhook',
+                    isFullPath: false,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Action',
+                            value: 'action',
+                        },
+                        {
+                            name: 'Chatbot',
+                            value: 'chatbot',
+                        },
+                        {
+                            name: 'Trigger',
+                            value: 'trigger',
+                        },
+                    ],
+                    default: 'action',
+                    description: 'Choose a resource - Trigger resource supports webhooks',
+                },
+                ...ActionDescription_1.actionOperations,
+                ...ActionDescription_1.actionFields,
+                ...ChatbotDescription_1.chatbotOperations,
+                ...ChatbotDescription_1.chatbotFields,
+                ...TriggerDescription_1.triggerOperations,
+                ...TriggerDescription_1.triggerFields,
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getChatbots() {
+                    const credentials = await this.getCredentials('chatDataApi');
+                    if (!credentials.baseUrl) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), new Error('Base URL is missing in credentials. Please check your credentials configuration.'), { itemIndex: 0 });
+                    }
+                    const baseUrl = credentials.baseUrl;
+                    const baseUrlFormatted = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+                    const fullUrl = `${baseUrlFormatted}/api/v2/get-chatbots`;
+                    try {
+                        const response = await this.helpers.httpRequest({
+                            url: fullUrl,
+                            method: 'GET',
+                            headers: {
+                                Authorization: `Bearer ${credentials.apiKey}`,
+                                'Accept': 'application/json',
+                                'Content-Type': 'application/json',
+                            },
+                            json: true,
+                            ignoreHttpStatusErrors: true,
+                        });
+                        if (response.status === 'error') {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), response.message, { itemIndex: 0 });
+                        }
+                        if (!response.chatbots || !Array.isArray(response.chatbots)) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), new Error('Invalid response format. Expected chatbots array.'), {
+                                itemIndex: 0,
+                            });
+                        }
+                        const options = response.chatbots.map((chatbot) => ({
+                            name: chatbot.chatbotName,
+                            value: chatbot.chatbotId,
+                        }));
+                        return options;
+                    }
+                    catch (error) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), new Error(`Failed to fetch chatbots: ${error.message}`), { itemIndex: 0 });
+                    }
+                },
+            },
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    const webhookData = this.getWorkflowStaticData('node');
+                    const chatbotId = webhookData.chatbotId;
+                    const webhookUrl = webhookData.webhookUrl;
+                    if (chatbotId && webhookUrl) {
+                        try {
+                            return true;
+                        }
+                        catch (error) {
+                            return false;
+                        }
+                    }
+                    return false;
+                },
+                async create() {
+                    try {
+                        const webhookUrl = this.getNodeWebhookUrl('default');
+                        const resource = this.getNodeParameter('resource');
+                        const operation = this.getNodeParameter('operation');
+                        if (resource === 'trigger') {
+                            let eventType = '';
+                            if (operation === 'onLeadSubmission') {
+                                eventType = 'lead-submission';
+                            }
+                            else if (operation === 'onLiveChatEscalation') {
+                                eventType = 'live-chat-escalation';
+                            }
+                            else if (operation === 'onNewMessage') {
+                                eventType = 'chat';
+                            }
+                            else {
+                                return false;
+                            }
+                            const chatbotId = this.getNodeParameter('chatbot_id');
+                            const credentials = await this.getCredentials('chatDataApi');
+                            const baseUrl = credentials.baseUrl;
+                            const baseUrlFormatted = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+                            const fullUrl = `${baseUrlFormatted}/api/v2/add-webhook`;
+                            const response = await this.helpers.httpRequest({
+                                url: fullUrl,
+                                method: 'POST',
+                                body: {
+                                    url: webhookUrl,
+                                    event: eventType,
+                                    chatbotId,
+                                },
+                                headers: {
+                                    Authorization: `Bearer ${credentials.apiKey}`,
+                                    'Accept': 'application/json',
+                                    'Content-Type': 'application/json',
+                                },
+                                json: true,
+                                ignoreHttpStatusErrors: true,
+                            });
+                            if (response.status === 'error') {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), response.message || 'Failed to register webhook');
+                            }
+                            const webhookData = this.getWorkflowStaticData('node');
+                            webhookData.chatbotId = chatbotId;
+                            webhookData.eventType = eventType;
+                            webhookData.webhookUrl = webhookUrl;
+                            webhookData.isPersistent = true;
+                            return true;
+                        }
+                        return false;
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                },
+                async delete() {
+                    try {
+                        const webhookData = this.getWorkflowStaticData('node');
+                        const nodeSettings = this.getNode();
+                        const workflowMode = this.getMode();
+                        const isNodeRemoved = nodeSettings.disabled === true;
+                        const isWorkflowDeleted = workflowMode === 'internal';
+                        if (!isNodeRemoved && !isWorkflowDeleted) {
+                            return true;
+                        }
+                        const chatbotId = webhookData.chatbotId;
+                        const webhookUrl = webhookData.webhookUrl;
+                        if (chatbotId && webhookUrl) {
+                            const credentials = await this.getCredentials('chatDataApi');
+                            const baseUrl = credentials.baseUrl;
+                            const baseUrlFormatted = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+                            const fullUrl = `${baseUrlFormatted}/api/v2/delete-webhook`;
+                            const response = await this.helpers.httpRequest({
+                                url: fullUrl,
+                                method: 'POST',
+                                body: {
+                                    url: webhookUrl,
+                                    chatbotId,
+                                },
+                                headers: {
+                                    Authorization: `Bearer ${credentials.apiKey}`,
+                                    'Accept': 'application/json',
+                                    'Content-Type': 'application/json',
+                                },
+                                json: true,
+                                ignoreHttpStatusErrors: true,
+                            });
+                            if (response.status === 'error') {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), response.message, { itemIndex: 0 });
+                            }
+                            delete webhookData.chatbotId;
+                            delete webhookData.eventType;
+                            delete webhookData.webhookUrl;
+                            delete webhookData.isPersistent;
+                            return true;
+                        }
+                        return false;
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                },
+            },
+        };
+    }
+    async webhook() {
+        const bodyData = this.getBodyData();
+        return {
+            workflowData: [
+                this.helpers.returnJsonArray(JSON.parse(JSON.stringify(bodyData)))
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        if (resource === 'action') {
+            if (operation === 'sendMessage') {
+                for (let i = 0; i < items.length; i++) {
+                    try {
+                        const chatbotId = this.getNodeParameter('chatbot_id', i);
+                        const messagesData = this.getNodeParameter('messages.messageValues', i, []);
+                        const additionalFields = this.getNodeParameter('additionalFields', i, {});
+                        if (!messagesData.length) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'At least one message is required', { itemIndex: i });
+                        }
+                        const messages = messagesData.map((message) => ({
+                            role: message.role,
+                            content: message.content,
+                        }));
+                        const body = {
+                            chatbotId,
+                            messages,
+                        };
+                        if (additionalFields.conversationId) {
+                            body.conversationId = additionalFields.conversationId;
+                        }
+                        if (additionalFields.baseModel) {
+                            body.baseModel = additionalFields.baseModel;
+                        }
+                        if (additionalFields.basePrompt) {
+                            body.basePrompt = additionalFields.basePrompt;
+                        }
+                        if (additionalFields.appendMessages !== undefined) {
+                            body.appendMessages = additionalFields.appendMessages;
+                        }
+                        else {
+                            body.appendMessages = true;
+                        }
+                        if (additionalFields.stream !== undefined) {
+                            body.stream = additionalFields.stream;
+                        }
+                        else {
+                            body.stream = false;
+                        }
+                        const credentials = await this.getCredentials('chatDataApi');
+                        const baseUrl = credentials.baseUrl;
+                        const baseUrlFormatted = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+                        const fullUrl = `${baseUrlFormatted}/api/v2/chat`;
+                        const response = await this.helpers.httpRequest({
+                            url: fullUrl,
+                            method: 'POST',
+                            body,
+                            headers: {
+                                Authorization: `Bearer ${credentials.apiKey}`,
+                                'Accept': 'application/json',
+                                'Content-Type': 'application/json',
+                            },
+                            json: true,
+                            ignoreHttpStatusErrors: true,
+                        });
+                        if (response.status === 'error') {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), response.message, { itemIndex: i });
+                        }
+                        const newItem = {
+                            json: {
+                                output: response,
+                            }
+                        };
+                        returnData.push(newItem);
+                    }
+                    catch (error) {
+                        let errorMessage = error.message;
+                        if (error.response && error.response.body) {
+                            const responseBody = error.response.body;
+                            if (typeof responseBody === 'object' && responseBody.message) {
+                                errorMessage = responseBody.message;
+                            }
+                            else if (typeof responseBody === 'string') {
+                                try {
+                                    const parsedBody = JSON.parse(responseBody);
+                                    if (parsedBody.message) {
+                                        errorMessage = parsedBody.message;
+                                    }
+                                }
+                                catch (e) {
+                                }
+                            }
+                        }
+                        if (this.continueOnFail()) {
+                            returnData.push({
+                                json: {
+                                    ...items[i].json,
+                                    error: errorMessage,
+                                },
+                                pairedItem: i,
+                            });
+                            continue;
+                        }
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage, { itemIndex: i });
+                    }
+                }
+            }
+            else if (operation === 'getLeads') {
+                try {
+                    const chatbotId = this.getNodeParameter('chatbot_id', 0);
+                    const limit = this.getNodeParameter('limit', 0);
+                    const additionalFields = this.getNodeParameter('additionalFields', 0, {});
+                    const returnData = [];
+                    let responseData = [];
+                    const qs = {
+                        size: 100,
+                    };
+                    if (additionalFields.startDate) {
+                        const startDate = new Date(additionalFields.startDate);
+                        qs.startTimestamp = startDate.getTime().toString();
+                    }
+                    if (additionalFields.endDate) {
+                        const endDate = new Date(additionalFields.endDate);
+                        qs.endTimestamp = endDate.getTime().toString();
+                    }
+                    if (additionalFields.source) {
+                        qs.source = additionalFields.source;
+                    }
+                    let hasNextPage = true;
+                    let pageNumber = 0;
+                    const credentials = await this.getCredentials('chatDataApi');
+                    const baseUrl = credentials.baseUrl;
+                    while (hasNextPage) {
+                        if (pageNumber > 0) {
+                            qs.start = (pageNumber * 100).toString();
+                        }
+                        const endpoint = `/get-customers/${chatbotId}`;
+                        const baseUrlFormatted = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+                        const fullUrl = `${baseUrlFormatted}/api/v2${endpoint}`;
+                        const response = await this.helpers.httpRequest({
+                            url: fullUrl,
+                            method: 'GET',
+                            qs,
+                            headers: {
+                                Authorization: `Bearer ${credentials.apiKey}`,
+                                'Accept': 'application/json',
+                                'Content-Type': 'application/json',
+                            },
+                            json: true,
+                            ignoreHttpStatusErrors: true,
+                        });
+                        if (response.status === 'error') {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), response.message, { itemIndex: 0 });
+                        }
+                        if (response && response.customers && Array.isArray(response.customers)) {
+                            responseData = [...responseData, ...response.customers];
+                            const totalResults = response.total;
+                            hasNextPage = totalResults > (pageNumber + 1) * 100;
+                            if (limit > 0 && responseData.length >= limit) {
+                                responseData = responseData.slice(0, limit);
+                                hasNextPage = false;
+                                break;
+                            }
+                            pageNumber++;
+                        }
+                        else {
+                            hasNextPage = false;
+                        }
+                    }
+                    for (const item of responseData) {
+                        returnData.push({
+                            json: item,
+                        });
+                    }
+                    return [returnData];
+                }
+                catch (error) {
+                    let errorMessage = error.message;
+                    if (error.response && error.response.body) {
+                        const responseBody = error.response.body;
+                        if (typeof responseBody === 'object' && responseBody.message) {
+                            errorMessage = responseBody.message;
+                        }
+                        else if (typeof responseBody === 'string') {
+                            try {
+                                const parsedBody = JSON.parse(responseBody);
+                                if (parsedBody.message) {
+                                    errorMessage = parsedBody.message;
+                                }
+                            }
+                            catch (e) {
+                            }
+                        }
+                    }
+                    if (this.continueOnFail()) {
+                        return [[{ json: { error: errorMessage } }]];
+                    }
+                    throw error;
+                }
+            }
+            else if (operation === 'getConversations') {
+                try {
+                    const chatbotId = this.getNodeParameter('chatbot_id', 0);
+                    const limit = this.getNodeParameter('limit', 0);
+                    const additionalFields = this.getNodeParameter('additionalFields', 0, {});
+                    const returnData = [];
+                    let responseData = [];
+                    const qs = {
+                        size: 100,
+                    };
+                    if (additionalFields.startDate) {
+                        const startDate = new Date(additionalFields.startDate);
+                        qs.startTimestamp = startDate.getTime().toString();
+                    }
+                    if (additionalFields.endDate) {
+                        const endDate = new Date(additionalFields.endDate);
+                        qs.endTimestamp = endDate.getTime().toString();
+                    }
+                    if (additionalFields.source) {
+                        qs.source = additionalFields.source;
+                    }
+                    if (additionalFields.leadId) {
+                        qs.leadId = additionalFields.leadId;
+                    }
+                    let hasNextPage = true;
+                    let pageNumber = 0;
+                    while (hasNextPage) {
+                        if (pageNumber > 0) {
+                            qs.start = (pageNumber * 100).toString();
+                        }
+                        const endpoint = `/get-conversations/${chatbotId}`;
+                        const credentials = await this.getCredentials('chatDataApi');
+                        const baseUrl = credentials.baseUrl;
+                        const baseUrlFormatted = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+                        const fullUrl = `${baseUrlFormatted}/api/v2${endpoint}`;
+                        const response = await this.helpers.httpRequest({
+                            url: fullUrl,
+                            method: 'GET',
+                            qs,
+                            headers: {
+                                Authorization: `Bearer ${credentials.apiKey}`,
+                                'Accept': 'application/json',
+                                'Content-Type': 'application/json',
+                            },
+                            json: true,
+                            ignoreHttpStatusErrors: true,
+                        });
+                        if (response.status === 'error') {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), response.message, { itemIndex: 0 });
+                        }
+                        if (response && response.conversations && Array.isArray(response.conversations)) {
+                            responseData = [...responseData, ...response.conversations];
+                            const totalResults = response.total;
+                            hasNextPage = totalResults > (pageNumber + 1) * 100;
+                            if (limit > 0 && responseData.length >= limit) {
+                                responseData = responseData.slice(0, limit);
+                                hasNextPage = false;
+                                break;
+                            }
+                            pageNumber++;
+                        }
+                        else {
+                            hasNextPage = false;
+                        }
+                    }
+                    for (const item of responseData) {
+                        returnData.push({
+                            json: item,
+                        });
+                    }
+                    return [returnData];
+                }
+                catch (error) {
+                    let errorMessage = error.message;
+                    if (error.response && error.response.body) {
+                        const responseBody = error.response.body;
+                        if (typeof responseBody === 'object' && responseBody.message) {
+                            errorMessage = responseBody.message;
+                        }
+                        else if (typeof responseBody === 'string') {
+                            try {
+                                const parsedBody = JSON.parse(responseBody);
+                                if (parsedBody.message) {
+                                    errorMessage = parsedBody.message;
+                                }
+                            }
+                            catch (e) {
+                            }
+                        }
+                    }
+                    if (this.continueOnFail()) {
+                        return [[{ json: { error: errorMessage } }]];
+                    }
+                    throw error;
+                }
+            }
+            else if (operation === 'makeApiCall') {
+                try {
+                    const url = this.getNodeParameter('url', 0);
+                    const method = this.getNodeParameter('method', 0);
+                    const responseFormat = this.getNodeParameter('responseFormat', 0);
+                    let fullUrl = url;
+                    if (url.startsWith('/api/v2/')) {
+                        const credentials = await this.getCredentials('chatDataApi');
+                        const baseUrl = credentials.baseUrl;
+                        const baseUrlFormatted = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+                        fullUrl = `${baseUrlFormatted}${url}`;
+                    }
+                    else {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'URL must start with "/api/v2/". Please use the format: /api/v2/your-endpoint', { itemIndex: 0 });
+                    }
+                    const credentials = await this.getCredentials('chatDataApi');
+                    const headerParameters = this.getNodeParameter('headers.parameters', 0, []);
+                    const headers = {};
+                    for (const param of headerParameters) {
+                        headers[param.name] = param.value;
+                    }
+                    headers['Authorization'] = `Bearer ${credentials.apiKey}`;
+                    const queryParameters = this.getNodeParameter('qs.parameters', 0, []);
+                    const qs = {};
+                    for (const param of queryParameters) {
+                        qs[param.name] = param.value;
+                    }
+                    let body;
+                    if (['POST', 'PUT', 'PATCH'].includes(method)) {
+                        const bodyParam = this.getNodeParameter('body', 0, '{}');
+                        try {
+                            body = JSON.parse(bodyParam);
+                        }
+                        catch (error) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Body must be a valid JSON object', { itemIndex: 0 });
+                        }
+                    }
+                    const requestOptions = {
+                        url: fullUrl,
+                        method: method,
+                        headers: headers,
+                    };
+                    if (Object.keys(qs).length > 0) {
+                        requestOptions.qs = qs;
+                    }
+                    if (body !== undefined) {
+                        requestOptions.body = body;
+                        requestOptions.json = true;
+                    }
+                    requestOptions.ignoreHttpStatusErrors = true;
+                    const response = await this.helpers.httpRequest(requestOptions);
+                    if (response && response.status === 'error') {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), response.message, { itemIndex: 0 });
+                    }
+                    let responseData;
+                    if (responseFormat === 'string' && typeof response === 'object') {
+                        responseData = JSON.stringify(response);
+                    }
+                    else {
+                        responseData = response;
+                    }
+                    const returnItem = {
+                        json: responseData,
+                    };
+                    return [[returnItem]];
+                }
+                catch (error) {
+                    let errorMessage = error.message;
+                    if (error.response && error.response.body) {
+                        const responseBody = error.response.body;
+                        if (typeof responseBody === 'object' && responseBody.message) {
+                            errorMessage = responseBody.message;
+                        }
+                        else if (typeof responseBody === 'string') {
+                            try {
+                                const parsedBody = JSON.parse(responseBody);
+                                if (parsedBody.message) {
+                                    errorMessage = parsedBody.message;
+                                }
+                            }
+                            catch (e) {
+                            }
+                        }
+                    }
+                    if (this.continueOnFail()) {
+                        return [[{
+                                    json: {
+                                        error: errorMessage,
+                                        statusCode: error.statusCode || 500,
+                                    }
+                                }]];
+                    }
+                    throw error;
+                }
+            }
+        }
+        else if (resource === 'chatbot') {
+            if (operation === 'updateBasePrompt') {
+                for (let i = 0; i < items.length; i++) {
+                    try {
+                        const chatbotId = this.getNodeParameter('chatbot_id', i);
+                        const basePrompt = this.getNodeParameter('basePrompt', i);
+                        const body = {
+                            chatbotId,
+                            basePrompt,
+                        };
+                        const credentials = await this.getCredentials('chatDataApi');
+                        const baseUrl = credentials.baseUrl;
+                        const baseUrlFormatted = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+                        const fullUrl = `${baseUrlFormatted}/api/v2/update-chatbot-settings`;
+                        const response = await this.helpers.httpRequest({
+                            url: fullUrl,
+                            method: 'POST',
+                            body,
+                            headers: {
+                                Authorization: `Bearer ${credentials.apiKey}`,
+                                'Accept': 'application/json',
+                                'Content-Type': 'application/json',
+                            },
+                            json: true,
+                            ignoreHttpStatusErrors: true,
+                        });
+                        if (response.status === 'error') {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), response.message, { itemIndex: i });
+                        }
+                        const newItem = {
+                            json: {
+                                ...response,
+                                success: true,
+                                chatbotId,
+                            },
+                        };
+                        returnData.push(newItem);
+                    }
+                    catch (error) {
+                        let errorMessage = error.message;
+                        if (error.response && error.response.body) {
+                            const responseBody = error.response.body;
+                            if (typeof responseBody === 'object' && responseBody.message) {
+                                errorMessage = responseBody.message;
+                            }
+                            else if (typeof responseBody === 'string') {
+                                try {
+                                    const parsedBody = JSON.parse(responseBody);
+                                    if (parsedBody.message) {
+                                        errorMessage = parsedBody.message;
+                                    }
+                                }
+                                catch (e) {
+                                }
+                            }
+                        }
+                        if (this.continueOnFail()) {
+                            returnData.push({
+                                json: {
+                                    ...items[i].json,
+                                    error: errorMessage,
+                                },
+                                pairedItem: i,
+                            });
+                            continue;
+                        }
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage, { itemIndex: i });
+                    }
+                }
+            }
+            else if (operation === 'retrainChatbot') {
+                for (let i = 0; i < items.length; i++) {
+                    try {
+                        const chatbotId = this.getNodeParameter('chatbot_id', i);
+                        const sourceText = this.getNodeParameter('sourceText', i, '');
+                        const qAndAsData = this.getNodeParameter('qAndAs.qAndAValues', i, []);
+                        const urlsData = this.getNodeParameter('urlsToScrape.urlValues', i, []);
+                        const scrapingOptions = this.getNodeParameter('options', i, {});
+                        const qAndAs = qAndAsData.length ? qAndAsData.map((qa) => ({
+                            question: qa.question,
+                            answer: qa.answer,
+                        })) : undefined;
+                        const urlsToScrape = urlsData.length ? urlsData.map((urlObj) => urlObj.url) : undefined;
+                        const body = {
+                            chatbotId,
+                        };
+                        if (sourceText) {
+                            body.sourceText = sourceText;
+                        }
+                        if (qAndAs && qAndAs.length) {
+                            body.qAndAs = qAndAs;
+                        }
+                        if (Array.isArray(urlsToScrape) && urlsToScrape.length) {
+                            body.urlsToScrape = urlsToScrape;
+                        }
+                        if (Object.keys(scrapingOptions).length) {
+                            body.options = scrapingOptions;
+                        }
+                        const credentials = await this.getCredentials('chatDataApi');
+                        const baseUrl = credentials.baseUrl;
+                        const baseUrlFormatted = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+                        const fullUrl = `${baseUrlFormatted}/api/v2/retrain-chatbot`;
+                        const response = await this.helpers.httpRequest({
+                            url: fullUrl,
+                            method: 'POST',
+                            body,
+                            headers: {
+                                Authorization: `Bearer ${credentials.apiKey}`,
+                                'Accept': 'application/json',
+                                'Content-Type': 'application/json',
+                            },
+                            json: true,
+                            ignoreHttpStatusErrors: true,
+                        });
+                        if (response.status === 'error') {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), response.message, { itemIndex: i });
+                        }
+                        const newItem = {
+                            json: {
+                                ...response,
+                                success: true,
+                                chatbotId,
+                            },
+                        };
+                        returnData.push(newItem);
+                    }
+                    catch (error) {
+                        let errorMessage = error.message;
+                        if (error.response && error.response.body) {
+                            const responseBody = error.response.body;
+                            if (typeof responseBody === 'object' && responseBody.message) {
+                                errorMessage = responseBody.message;
+                            }
+                            else if (typeof responseBody === 'string') {
+                                try {
+                                    const parsedBody = JSON.parse(responseBody);
+                                    if (parsedBody.message) {
+                                        errorMessage = parsedBody.message;
+                                    }
+                                }
+                                catch (e) {
+                                }
+                            }
+                        }
+                        if (this.continueOnFail()) {
+                            returnData.push({
+                                json: {
+                                    ...items[i].json,
+                                    error: errorMessage,
+                                },
+                                pairedItem: i,
+                            });
+                            continue;
+                        }
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage, { itemIndex: i });
+                    }
+                }
+            }
+            else if (operation === 'getChatbotStatus') {
+                try {
+                    const chatbotId = this.getNodeParameter('chatbot_id', 0);
+                    const endpoint = `/chatbot/status/${chatbotId}`;
+                    const credentials = await this.getCredentials('chatDataApi');
+                    const baseUrl = credentials.baseUrl;
+                    const baseUrlFormatted = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+                    const fullUrl = `${baseUrlFormatted}/api/v2${endpoint}`;
+                    const response = await this.helpers.httpRequest({
+                        url: fullUrl,
+                        method: 'GET',
+                        headers: {
+                            Authorization: `Bearer ${credentials.apiKey}`,
+                            'Accept': 'application/json',
+                            'Content-Type': 'application/json',
+                        },
+                        json: true,
+                        ignoreHttpStatusErrors: true,
+                    });
+                    if (response.status === 'error') {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), response.message, { itemIndex: 0 });
+                    }
+                    return [[{ json: response }]];
+                }
+                catch (error) {
+                    let errorMessage = error.message;
+                    if (error.response && error.response.body) {
+                        const responseBody = error.response.body;
+                        if (typeof responseBody === 'object' && responseBody.message) {
+                            errorMessage = responseBody.message;
+                        }
+                        else if (typeof responseBody === 'string') {
+                            try {
+                                const parsedBody = JSON.parse(responseBody);
+                                if (parsedBody.message) {
+                                    errorMessage = parsedBody.message;
+                                }
+                            }
+                            catch (e) {
+                            }
+                        }
+                    }
+                    if (this.continueOnFail()) {
+                        return [[{ json: { error: errorMessage } }]];
+                    }
+                    throw error;
+                }
+            }
+            else if (operation === 'createChatbot') {
+                try {
+                    const chatbotName = this.getNodeParameter('chatbotName', 0);
+                    const model = this.getNodeParameter('model', 0);
+                    const sourceText = this.getNodeParameter('sourceText', 0, '');
+                    const urlsData = this.getNodeParameter('urlsToScrape.urlValues', 0, []);
+                    const urlsToScrape = urlsData.length ? urlsData.map((urlObj) => urlObj.url) : undefined;
+                    const body = {
+                        chatbotName,
+                        model,
+                    };
+                    if (sourceText) {
+                        body.sourceText = sourceText;
+                    }
+                    if (Array.isArray(urlsToScrape) && urlsToScrape.length) {
+                        body.urlsToScrape = urlsToScrape;
+                    }
+                    if (model === 'custom-model') {
+                        const customBackend = this.getNodeParameter('customBackend', 0, '');
+                        const bearer = this.getNodeParameter('bearer', 0, '');
+                        if (customBackend) {
+                            body.customBackend = customBackend;
+                        }
+                        if (bearer) {
+                            body.bearer = bearer;
+                        }
+                    }
+                    const credentials = await this.getCredentials('chatDataApi');
+                    const baseUrl = credentials.baseUrl;
+                    const baseUrlFormatted = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+                    const fullUrl = `${baseUrlFormatted}/api/v2/create-chatbot`;
+                    const response = await this.helpers.httpRequest({
+                        url: fullUrl,
+                        method: 'POST',
+                        body,
+                        headers: {
+                            Authorization: `Bearer ${credentials.apiKey}`,
+                            'Accept': 'application/json',
+                            'Content-Type': 'application/json',
+                        },
+                        json: true,
+                        ignoreHttpStatusErrors: true,
+                    });
+                    if (response.status === 'error') {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), response.message, { itemIndex: 0 });
+                    }
+                    return [[{ json: response }]];
+                }
+                catch (error) {
+                    let errorMessage = error.message;
+                    if (error.response && error.response.body) {
+                        const responseBody = error.response.body;
+                        if (typeof responseBody === 'object' && responseBody.message) {
+                            errorMessage = responseBody.message;
+                        }
+                        else if (typeof responseBody === 'string') {
+                            try {
+                                const parsedBody = JSON.parse(responseBody);
+                                if (parsedBody.message) {
+                                    errorMessage = parsedBody.message;
+                                }
+                            }
+                            catch (e) {
+                            }
+                        }
+                    }
+                    if (this.continueOnFail()) {
+                        return [[{ json: { error: errorMessage } }]];
+                    }
+                    throw error;
+                }
+            }
+        }
+        else if (resource === 'trigger') {
+            if (operation === 'onLeadSubmission' || operation === 'onLiveChatEscalation' || operation === 'onNewMessage') {
+                let incomingData;
+                if (typeof items[0].json === 'object' && items[0].json !== null) {
+                    incomingData = items[0].json;
+                }
+                else {
+                    incomingData = JSON.parse(String(items[0].json));
+                }
+                const newItem = {
+                    json: incomingData,
+                };
+                returnData.push(newItem);
+            }
+            else {
+                for (let i = 0; i < items.length; i++) {
+                    try {
+                        const pollInterval = this.getNodeParameter('pollInterval', i);
+                        const newItem = {
+                            json: {
+                                ...items[i].json,
+                                success: true,
+                                resource: 'trigger',
+                                operation,
+                                pollInterval,
+                            },
+                        };
+                        returnData.push(newItem);
+                    }
+                    catch (error) {
+                        let errorMessage = error.message;
+                        if (error.response && error.response.body) {
+                            const responseBody = error.response.body;
+                            if (typeof responseBody === 'object' && responseBody.message) {
+                                errorMessage = responseBody.message;
+                            }
+                            else if (typeof responseBody === 'string') {
+                                try {
+                                    const parsedBody = JSON.parse(responseBody);
+                                    if (parsedBody.message) {
+                                        errorMessage = parsedBody.message;
+                                    }
+                                }
+                                catch (e) {
+                                }
+                            }
+                        }
+                        if (this.continueOnFail()) {
+                            returnData.push({
+                                json: {
+                                    ...items[i].json,
+                                    error: errorMessage,
+                                },
+                                pairedItem: i,
+                            });
+                            continue;
+                        }
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage, { itemIndex: i });
+                    }
+                }
+            }
+        }
+        return [returnData.length ? returnData : items];
+    }
+}
+exports.ChatData = ChatData;
+//# sourceMappingURL=ChatData.node.js.map