@app-connect/core 1.7.22 → 1.7.24

package/docs/libraries.md

@@ -74,7 +74,7 @@ It supports:
 - session id, subject, duration, result, recording, and timestamp formatting
 - transcript and AI note insertion
 - leg journey formatting
-- RingSense transcript, summary, score, bullet summary, and deep link sections
+- ACE transcript, summary, score, bullet summary, and deep link sections
 
 ### `lib/sharedSMSComposer.js`
 

package/handlers/admin.js

@@ -6,6 +6,7 @@ const { RingCentral } = require('../lib/ringcentral');
 const { Connector } = require('../models/dynamo/connectorSchema');
 const logger = require('../lib/logger');
 const { handleDatabaseError } = require('../lib/errorHandler');
+const { getHashValue } = require('../lib/util');
 
 const CALL_AGGREGATION_GROUPS = ["Company", "CompanyNumbers", "Users", "Queues", "IVRs", "IVAs", "SharedLines", "UserGroups", "Sites", "Departments"]
 const RC_EXTENSION_ENDPOINT = 'https://platform.ringcentral.com/restapi/v1.0/account/~/extension/~';
@@ -108,7 +109,8 @@ async function getAdminReport({ rcAccountId, timezone, timeFrom, timeTo, groupBy
             clientSecret: process.env.RINGCENTRAL_CLIENT_SECRET,
             redirectUri: `${process.env.APP_SERVER}/ringcentral/oauth/callback`
         });
-        let adminConfig = await AdminConfigModel.findByPk(rcAccountId);
+        const hashedRcAccountId = getHashValue(rcAccountId, process.env.HASH_KEY);
+        let adminConfig = await AdminConfigModel.findByPk(hashedRcAccountId);
         const isTokenExpired = adminConfig.adminTokenExpiry < new Date();
         if (isTokenExpired) {
             const { access_token, refresh_token, expire_time } = await rcSDK.refreshToken({
@@ -116,7 +118,7 @@ async function getAdminReport({ rcAccountId, timezone, timeFrom, timeTo, groupBy
                 expires_in: adminConfig.adminTokenExpiry,
                 refresh_token_expires_in: adminConfig.adminTokenExpiry
             });
-            adminConfig = await AdminConfigModel.update({ adminAccessToken: access_token, adminRefreshToken: refresh_token, adminTokenExpiry: expire_time }, { where: { id: rcAccountId } });
+            adminConfig = await AdminConfigModel.update({ adminAccessToken: access_token, adminRefreshToken: refresh_token, adminTokenExpiry: expire_time }, { where: { id: hashedRcAccountId } });
         }
         const callsAggregationData = await rcSDK.getCallsAggregationData({
             token: { access_token: adminConfig.adminAccessToken, token_type: 'Bearer' },
@@ -177,7 +179,8 @@ async function getUserReport({ rcAccountId, rcExtensionId, timezone, timeFrom, t
             clientSecret: process.env.RINGCENTRAL_CLIENT_SECRET,
             redirectUri: `${process.env.APP_SERVER}/ringcentral/oauth/callback`
         });
-        let adminConfig = await AdminConfigModel.findByPk(rcAccountId);
+        const hashedRcAccountId = getHashValue(rcAccountId, process.env.HASH_KEY);
+        let adminConfig = await AdminConfigModel.findByPk(hashedRcAccountId);
         const isTokenExpired = adminConfig.adminTokenExpiry < new Date();
         if (isTokenExpired) {
             const { access_token, refresh_token, expire_time } = await rcSDK.refreshToken({
@@ -185,7 +188,7 @@ async function getUserReport({ rcAccountId, rcExtensionId, timezone, timeFrom, t
                 expires_in: adminConfig.adminTokenExpiry,
                 refresh_token_expires_in: adminConfig.adminTokenExpiry
             });
-            adminConfig = await AdminConfigModel.update({ adminAccessToken: access_token, adminRefreshToken: refresh_token, adminTokenExpiry: expire_time }, { where: { id: rcAccountId } });
+            adminConfig = await AdminConfigModel.update({ adminAccessToken: access_token, adminRefreshToken: refresh_token, adminTokenExpiry: expire_time }, { where: { id: hashedRcAccountId } });
         }
         const callLogData = await rcSDK.getCallLogData({
             extensionId: rcExtensionId,

package/handlers/auth.js

@@ -7,6 +7,7 @@ const adminCore = require('./admin');
 const { Connector } = require('../models/dynamo/connectorSchema');
 const { handleDatabaseError } = require('../lib/errorHandler');
 const managedAuthCore = require('./managedAuth');
+const { getHashValue } = require('../lib/util');
 
 async function onOAuthCallback({ platform, hostname, tokenUrl, query, hashedRcExtensionId, isFromMCP = false }) {
     const callbackUri = query.callbackUri;
@@ -80,10 +81,16 @@ async function onOAuthCallback({ platform, hostname, tokenUrl, query, hashedRcEx
 
 async function onApiKeyLogin({ platform, hostname, apiKey, proxyId, rcAccountId, rcExtensionId, connectorId, isPrivate, hashedRcExtensionId, additionalInfo }) {
     const platformModule = connectorRegistry.getConnector(platform);
-    let resolvedAdditionalInfo = additionalInfo;
+    let resolvedAdditionalInfo = {
+        ...(additionalInfo ?? {})
+    };
+    if (resolvedAdditionalInfo.apiKey === undefined && apiKey !== undefined) {
+        resolvedAdditionalInfo.apiKey = apiKey;
+    }
     let resolvedApiKey = apiKey;
-    if (rcAccountId && rcExtensionId) {
-        const managedFieldDefinitions = await managedAuthCore.getManagedFieldDefinitions({ platform, connectorId, isPrivate });
+    let managedFieldDefinitions = [];
+    if (rcAccountId) {
+        managedFieldDefinitions = await managedAuthCore.getManagedFieldDefinitions({ platform, connectorId, isPrivate });
         const shouldFallbackToManualAuth = managedFieldDefinitions.length > 0
             && await managedAuthCore.hasManagedAuthLoginFailure({ rcAccountId, platform, rcExtensionId });
         const managedAuthResult = await managedAuthCore.resolveApiKeyLoginFields({
@@ -93,7 +100,7 @@ async function onApiKeyLogin({ platform, hostname, apiKey, proxyId, rcAccountId,
             connectorId,
             isPrivate,
             apiKey,
-            additionalInfo,
+            additionalInfo: resolvedAdditionalInfo,
             preferSubmittedValuesForManagedFields: shouldFallbackToManualAuth
         });
         resolvedAdditionalInfo = managedAuthResult.resolvedAdditionalInfo;
@@ -273,8 +280,9 @@ async function onRingcentralOAuthCallback({ code, rcAccountId }) {
         redirectUri: `${process.env.APP_SERVER}/ringcentral/oauth/callback`
     });
     const { access_token, refresh_token, expire_time } = await rcSDK.generateToken({ code });
+    const hashedRcAccountId = getHashValue(rcAccountId, process.env.HASH_KEY);
     await adminCore.updateAdminRcTokens({
-        hashedRcAccountId: rcAccountId,
+        hashedRcAccountId,
         adminAccessToken: access_token,
         adminRefreshToken: refresh_token,
         adminTokenExpiry: expire_time

package/handlers/log.js

@@ -18,8 +18,32 @@ const logger = require('../lib/logger');
 const { handleApiError, handleDatabaseError } = require('../lib/errorHandler');
 const { v4: uuidv4 } = require('uuid');
 const { AccountDataModel } = require('../models/accountDataModel');
+const pluginCore = require('./plugin');
 
-async function createCallLog({ jwtToken, platform, userId, incomingData, hashedAccountId, isFromSSCL }) {
+function mergePluginWarnings({ returnMessage, warningMessages }) {
+    if (!warningMessages.length) {
+        return returnMessage;
+    }
+    const warningMessage = warningMessages.join(' ');
+    if (!returnMessage) {
+        return {
+            message: warningMessage,
+            messageType: 'warning',
+            ttl: 5000,
+        };
+    }
+    return {
+        ...returnMessage,
+        message: `${returnMessage.message || ''} ${warningMessage}`.trim(),
+        messageType: returnMessage.messageType === 'error' ? 'error' : 'warning',
+    };
+}
+
+function getPluginWarningMessage({ pluginId }) {
+    return `Plugin ${pluginId} skipped: missing account-level plugin jwtToken. Reinstall or re-register plugin.`;
+}
+
+async function createCallLog({ platform, userId, incomingData, hashedAccountId, isFromSSCL }) {
     try {
         let existingCallLog = null;
         try {
@@ -122,56 +146,78 @@ async function createCallLog({ jwtToken, platform, userId, incomingData, hashedA
 
 
         const pluginAsyncTaskIds = [];
+        const pluginWarnings = [];
         // Plugins
-        const loggingPlugins = getPluginsFromUserSettings({ userSettings: user.userSettings, logType: 'call' });
-        for (const pluginSetting of loggingPlugins) {
-            const pluginId = pluginSetting.id;
-            let pluginDataResponse = null;
-            switch (pluginSetting.value.access) {
-                case 'public':
-                    pluginDataResponse = await axios.get(`https://appconnect.labs.ringcentral.com/public-api/connectors/${pluginId}/manifest?type=plugin`);
-                    break;
-                case 'private':
-                case 'shared':
-                    pluginDataResponse = await axios.get(`https://appconnect.labs.ringcentral.com/public-api/connectors/${pluginId}/manifest?access=internal&type=connector&accountId=${user.rcAccountId}`);
-                    break;
-                default:
-                    throw new Error('Invalid plugin access');
-            }
-            const pluginData = pluginDataResponse.data;
-            const pluginManifest = pluginData.platforms[pluginSetting.value.name];
-            let pluginEndpointUrl = pluginManifest.endpointUrl;
+        const accountPlugins = await pluginCore.getPluginsFromRcAccountId({ rcAccountId: user.rcAccountId });
+        const callPlugins = accountPlugins.filter(plugin => plugin.data.supportedLogTypes.includes('call'));
+        for (const plugin of callPlugins) {
+            const pluginId = plugin.id;
+            const pluginJwtToken = plugin.data.jwtToken;
+            const pluginManifest = plugin.data;
+            const pluginEndpointUrl = pluginManifest.endpointUrl;
             if (!pluginEndpointUrl) {
                 throw new Error('Plugin URL is not set');
             }
-            else {
-                // check if endpoint has query params already
-                if (pluginEndpointUrl.includes('?')) {
-                    pluginEndpointUrl += `&jwtToken=${jwtToken}`;
-                }
-                else {
-                    pluginEndpointUrl += `?jwtToken=${jwtToken}`;
-                }
-            }
-            if (pluginSetting.value.isAsync) {
+            const userConfig = pluginCore.getPluginConfigFromUserSettings({ userSettings: user.userSettings, pluginId });
+            if (plugin.data.isAsync) {
                 const asyncTaskId = `${userId}-${uuidv4()}`;
                 pluginAsyncTaskIds.push(asyncTaskId);
                 await CacheModel.create({
                     id: asyncTaskId,
                     status: 'initialized',
                     userId,
-                    cacheKey: `pluginTask-${pluginSetting.value.name}`,
+                    cacheKey: `pluginTask-${plugin.data.name}`,
                     expiry: moment().add(1, 'hour').toDate()
                 });
-                axios.post(pluginEndpointUrl, {
-                    data: incomingData,
-                    asyncTaskId
-                });
+                try {
+                    const syncPluginTokenResponse = await axios.post(plugin.data.tokenSyncUrl, {},
+                        {
+                            headers: {
+                                Authorization: `Bearer ${pluginJwtToken}`,
+                            }
+                        }
+                    )
+                    const syncedPluginJwtToken = syncPluginTokenResponse?.data?.jwtToken ?? pluginJwtToken;
+                    axios.post(pluginEndpointUrl, {
+                        data: incomingData,
+                        config: userConfig,
+                        asyncTaskId
+                    }, {
+                        headers: {
+                            Authorization: `Bearer ${syncedPluginJwtToken ?? pluginJwtToken}`,
+                        },
+                    });
+                    if (syncedPluginJwtToken) {
+                        pluginCore.persistPluginData({
+                            rcAccountId: user.rcAccountId,
+                            platformName: platform,
+                            pluginId,
+                            jwtToken: syncedPluginJwtToken,
+                        });
+                    }
+                }
+                catch (error) {
+                    logger.error('Error syncing plugin JWT token', { stack: error.stack });
+                }
             }
             else {
                 const processedResultResponse = await axios.post(pluginEndpointUrl, {
-                    data: incomingData
+                    data: incomingData,
+                    config: userConfig,
+                }, {
+                    headers: {
+                        Authorization: `Bearer ${pluginJwtToken}`,
+                    },
                 });
+                const refreshedPluginJwtToken = pluginCore.getRefreshedJwtTokenFromHeaders({ headers: processedResultResponse.headers });
+                if (refreshedPluginJwtToken) {
+                    pluginCore.persistPluginData({
+                        rcAccountId: user.rcAccountId,
+                        platformName: platform,
+                        pluginId,
+                        jwtToken: refreshedPluginJwtToken,
+                    });
+                }
                 // eslint-disable-next-line no-param-reassign
                 incomingData = processedResultResponse.data;
                 note = incomingData.note;
@@ -242,7 +288,13 @@ async function createCallLog({ jwtToken, platform, userId, incomingData, hashedA
             catch (error) {
                 return handleDatabaseError(error, 'Error creating call log');
             }
-            return { successful: !!logId, logId, returnMessage, extraDataTracking, pluginAsyncTaskIds };
+            return {
+                successful: !!logId,
+                logId,
+                returnMessage: mergePluginWarnings({ returnMessage, warningMessages: pluginWarnings }),
+                extraDataTracking,
+                pluginAsyncTaskIds
+            };
         }
     } catch (e) {
         return handleApiError(e, platform, 'createCallLog', { userId });
@@ -348,7 +400,7 @@ async function getCallLog({ userId, sessionIds, platform, requireDetails }) {
     }
 }
 
-async function updateCallLog({ jwtToken, platform, userId, incomingData, hashedAccountId, isFromSSCL }) {
+async function updateCallLog({ platform, userId, incomingData, hashedAccountId, isFromSSCL }) {
     try {
         let existingCallLog = null;
         try {
@@ -398,55 +450,78 @@ async function updateCallLog({ jwtToken, platform, userId, incomingData, hashedA
             }
 
             const pluginAsyncTaskIds = [];
+            const pluginWarnings = [];
             // Plugins
-            const plugins = getPluginsFromUserSettings({ userSettings: user.userSettings, logType: 'call' });
-            for (const pluginSetting of plugins) {
-                const pluginId = pluginSetting.id;
-                let pluginDataResponse = null;
-                switch (pluginSetting.value.access) {
-                    case 'public':
-                        pluginDataResponse = await axios.get(`https://appconnect.labs.ringcentral.com/public-api/connectors/${pluginId}/manifest?type=plugin`);
-                        break;
-                    case 'private':
-                    case 'shared':
-                        pluginDataResponse = await axios.get(`https://appconnect.labs.ringcentral.com/public-api/connectors/${pluginId}/manifest?access=internal&type=connector&accountId=${user.rcAccountId}`);
-                        break;
-                    default:
-                        throw new Error('Invalid plugin access');
-                }
-                const pluginData = pluginDataResponse.data;
-                const pluginManifest = pluginData.platforms[pluginSetting.value.name];
-                let pluginEndpointUrl = pluginManifest.endpointUrl;
+            const accountPlugins = await pluginCore.getPluginsFromRcAccountId({ rcAccountId: user.rcAccountId });
+            const callPlugins = accountPlugins.filter(plugin => plugin.data.supportedLogTypes.includes('call'));
+            for (const plugin of callPlugins) {
+                const pluginId = plugin.id;
+                const pluginJwtToken = plugin.data.jwtToken;
+                const pluginManifest = plugin.data;
+                const pluginEndpointUrl = pluginManifest.endpointUrl;
                 if (!pluginEndpointUrl) {
                     throw new Error('Plugin URL is not set');
                 }
-                else {
-                    if (pluginEndpointUrl.includes('?')) {
-                        pluginEndpointUrl += `&jwtToken=${jwtToken}`;
-                    }
-                    else {
-                        pluginEndpointUrl += `?jwtToken=${jwtToken}`;
-                    }
-                }
-                if (pluginSetting.value.isAsync) {
+                const userConfig = pluginCore.getPluginConfigFromUserSettings({ userSettings: user.userSettings, pluginId });
+                if (plugin.data.isAsync) {
                     const asyncTaskId = `${userId}-${uuidv4()}`;
                     pluginAsyncTaskIds.push(asyncTaskId);
                     await CacheModel.create({
                         id: asyncTaskId,
                         status: 'initialized',
                         userId,
-                        cacheKey: `pluginTask-${pluginSetting.value.name}`,
+                        cacheKey: `pluginTask-${plugin.data.name}`,
                         expiry: moment().add(1, 'hour').toDate()
                     });
-                    axios.post(pluginEndpointUrl, {
-                        data: { logInfo: incomingData },
-                        asyncTaskId
-                    });
+                    try {
+                        const syncPluginTokenResponse = await axios.post(plugin.data.tokenSyncUrl, {},
+                            {
+                                headers: {
+                                    Authorization: `Bearer ${pluginJwtToken}`,
+                                },
+                            }
+                        );
+                        const syncedPluginJwtToken = pluginCore.getRefreshedJwtTokenFromHeaders({ headers: syncPluginTokenResponse.headers });
+                        axios.post(pluginEndpointUrl, {
+                            data: { logInfo: incomingData },
+                            config: userConfig,
+                            asyncTaskId
+                        }, {
+                            headers: {
+                                Authorization: `Bearer ${syncedPluginJwtToken ?? pluginJwtToken}`,
+                            },
+                        });
+                        if (syncedPluginJwtToken) {
+                            pluginCore.persistPluginData({
+                                rcAccountId: user.rcAccountId,
+                                platformName: platform,
+                                pluginId,
+                                jwtToken: syncedPluginJwtToken,
+                            });
+                        }
+                    }
+                    catch (error) {
+                        logger.error('Error syncing plugin JWT token', { stack: error.stack });
+                    }
                 }
                 else {
                     const processedResultResponse = await axios.post(pluginEndpointUrl, {
-                        data: incomingData
+                        data: incomingData,
+                        config: userConfig
+                    }, {
+                        headers: {
+                            Authorization: `Bearer ${pluginJwtToken}`,
+                        },
                     });
+                    const refreshedPluginJwtToken = pluginCore.getRefreshedJwtTokenFromHeaders({ headers: processedResultResponse.headers });
+                    if (refreshedPluginJwtToken) {
+                        pluginCore.persistPluginData({
+                            rcAccountId: user.rcAccountId,
+                            platformName: platform,
+                            pluginId,
+                            jwtToken: refreshedPluginJwtToken,
+                        });
+                    }
                     // eslint-disable-next-line no-param-reassign
                     incomingData = processedResultResponse.data;
                 }
@@ -534,7 +609,14 @@ async function updateCallLog({ jwtToken, platform, userId, incomingData, hashedA
                 isFromSSCL,
                 proxyConfig,
             });
-            return { successful: true, logId: existingCallLog.thirdPartyLogId, updatedNote, returnMessage, extraDataTracking, pluginAsyncTaskIds };
+            return {
+                successful: true,
+                logId: existingCallLog.thirdPartyLogId,
+                updatedNote,
+                returnMessage: mergePluginWarnings({ returnMessage, warningMessages: pluginWarnings }),
+                extraDataTracking,
+                pluginAsyncTaskIds
+            };
         }
         return { successful: false };
     } catch (e) {
@@ -632,59 +714,82 @@ async function createMessageLog({ platform, userId, incomingData }) {
         const isSharedSMS = !!ownerName;
 
         const pluginAsyncTaskIds = [];
+        const pluginWarnings = [];
         // Plugins
         const isSMS = incomingData.logInfo.messages.some(m => m.type === 'SMS');
         const isFax = incomingData.logInfo.messages.some(m => m.type === 'Fax');
-        const smsPlugins = isSMS ? getPluginsFromUserSettings({ userSettings: user.userSettings, logType: 'sms' }) : [];
-        const faxPlugins = isFax ? getPluginsFromUserSettings({ userSettings: user.userSettings, logType: 'fax' }) : [];
+        const accountPlugins = await pluginCore.getPluginsFromRcAccountId({ rcAccountId: user.rcAccountId });
+        const smsPlugins = isSMS ? accountPlugins.filter(plugin => plugin.data.supportedLogTypes.includes('sms')) : [];
+        const faxPlugins = isFax ? accountPlugins.filter(plugin => plugin.data.supportedLogTypes.includes('fax')) : [];
         const plugins = [...smsPlugins, ...faxPlugins];
-        for (const pluginSetting of plugins) {
-            const pluginId = pluginSetting.id;
-            let pluginDataResponse = null;
-            switch (pluginSetting.value.access) {
-                case 'public':
-                    pluginDataResponse = await axios.get(`https://appconnect.labs.ringcentral.com/public-api/connectors/${pluginId}/manifest?type=plugin`);
-                    break;
-                case 'private':
-                case 'shared':
-                    pluginDataResponse = await axios.get(`https://appconnect.labs.ringcentral.com/public-api/connectors/${pluginId}/manifest?access=internal&type=connector&accountId=${user.rcAccountId}`);
-                    break;
-                default:
-                    throw new Error('Invalid plugin access');
-            }
-            const pluginData = pluginDataResponse.data;
-            const pluginManifest = pluginData.platforms[pluginSetting.value.name];
-            let pluginEndpointUrl = pluginManifest.endpointUrl;
+        for (const plugin of plugins) {
+            const pluginId = plugin.id;
+            const pluginJwtToken = plugin.data.jwtToken;
+            const pluginManifest = plugin.data;
+            const pluginEndpointUrl = pluginManifest.endpointUrl;
             if (!pluginEndpointUrl) {
                 throw new Error('Plugin URL is not set');
             }
-            else {
-                if (pluginEndpointUrl.includes('?')) {
-                    pluginEndpointUrl += `&jwtToken=${jwtToken}`;
-                }
-                else {
-                    pluginEndpointUrl += `?jwtToken=${jwtToken}`;
-                }
-            }
-            if (pluginSetting.value.isAsync) {
+            const userConfig = pluginCore.getPluginConfigFromUserSettings({ userSettings: user.userSettings, pluginId });
+            if (plugin.data.isAsync) {
                 const asyncTaskId = `${userId}-${uuidv4()}`;
                 pluginAsyncTaskIds.push(asyncTaskId);
                 await CacheModel.create({
                     id: asyncTaskId,
                     status: 'initialized',
                     userId,
-                    cacheKey: `pluginTask-${pluginSetting.value.name}`,
+                    cacheKey: `pluginTask-${plugin.data.name}`,
                     expiry: moment().add(1, 'hour').toDate()
                 });
-                axios.post(pluginEndpointUrl, {
-                    data: { logInfo: incomingData },
-                    asyncTaskId
-                });
+                try {
+                    const syncPluginTokenResponse = await axios.post(plugin.data.tokenSyncUrl, {},
+                        {
+                            headers: {
+                                Authorization: `Bearer ${pluginJwtToken}`,
+                            },
+                        }
+                    );
+                    const syncedPluginJwtToken = pluginCore.getRefreshedJwtTokenFromHeaders({ headers: syncPluginTokenResponse.headers });
+                    axios.post(pluginEndpointUrl, {
+                        data: { logInfo: incomingData },
+                        config: userConfig,
+                        asyncTaskId
+                    }, {
+                        headers: {
+                            Authorization: `Bearer ${syncedPluginJwtToken ?? pluginJwtToken}`,
+                        },
+                    });
+                    if (syncedPluginJwtToken) {
+                        pluginCore.persistPluginData({
+                            rcAccountId: user.rcAccountId,
+                            platformName: platform,
+                            pluginId,
+                            jwtToken: syncedPluginJwtToken,
+                        });
+                    }
+                }
+                catch (error) {
+                    logger.error('Error syncing plugin JWT token', { stack: error.stack });
+                }
             }
             else {
                 const processedResultResponse = await axios.post(pluginEndpointUrl, {
-                    data: incomingData
+                    data: incomingData,
+                    config: userConfig,
+                }, {
+                    headers: {
+                        Authorization: `Bearer ${pluginJwtToken}`,
+                    },
                 });
+                const refreshedPluginJwtToken = pluginCore.getRefreshedJwtTokenFromHeaders({ headers: processedResultResponse.headers });
+                if (refreshedPluginJwtToken) {
+                    pluginCore.persistPluginData({
+                        rcAccountId: user.rcAccountId,
+                        platformName: platform,
+                        pluginId,
+                        jwtToken: refreshedPluginJwtToken,
+                    });
+                }
                 // eslint-disable-next-line no-param-reassign
                 incomingData = processedResultResponse.data;
             }
@@ -731,7 +836,6 @@ async function createMessageLog({ platform, userId, incomingData }) {
                     conversationLogId: incomingData.logInfo.conversationLogId
                 }
             });
-            const entities = incomingData.logInfo.entities;
             const sharedSMSLogContent = composeSharedSMSLog({ logFormat: platformModule.getLogFormatType(platform, proxyConfig), conversation: incomingData.logInfo, contactName: contactInfo.name, timezoneOffset: user.timezoneOffset });
             if (existingMessageLog) {
                 const updateMessageResult = await platformModule.updateMessageLog({ user, contactInfo, sharedSMSLogContent, existingMessageLog: existingMessageLog, authHeader, additionalSubmission, proxyConfig });
@@ -739,7 +843,6 @@ async function createMessageLog({ platform, userId, incomingData }) {
             }
             else {
                 const createMessageLogResult = await platformModule.createMessageLog({ user, contactInfo, sharedSMSLogContent, authHeader, additionalSubmission, proxyConfig });
-                const crmLogId = createMessageLogResult.logId;
                 returnMessage = createMessageLogResult?.returnMessage;
                 extraDataTracking = createMessageLogResult.extraDataTracking;
                 if (createMessageLogResult.logId) {
@@ -841,7 +944,12 @@ async function createMessageLog({ platform, userId, incomingData }) {
                 }
             }
         }
-        return { successful: true, logIds, returnMessage, extraDataTracking };
+        return {
+            successful: true,
+            logIds,
+            returnMessage: mergePluginWarnings({ returnMessage, warningMessages: pluginWarnings }),
+            extraDataTracking
+        };
     }
     catch (e) {
         return handleApiError(e, platform, 'createMessageLog', { userId });
@@ -862,4 +970,4 @@ exports.createCallLog = createCallLog;
 exports.updateCallLog = updateCallLog;
 exports.createMessageLog = createMessageLog;
 exports.getCallLog = getCallLog;
-exports.saveNoteCache = saveNoteCache;
+exports.saveNoteCache = saveNoteCache;