@app-connect/core 1.7.32 → 1.7.33

package/handlers/plugin.js

@@ -51,29 +51,6 @@ async function getPluginLicenseStatus({ rcAccountId, pluginId }) {
     return licenseStatusResponse.data;
 }
 
-async function getPluginAsyncTasks({ asyncTaskIds }) {
-    const caches = await CacheModel.findAll({
-        where: {
-            id: {
-                [Op.in]: asyncTaskIds
-            }
-        }
-    });
-    const result = caches.map(cache => ({
-        cacheKey: cache.cacheKey,
-        status: cache.status
-    }));
-    const toRemoveCaches = caches.filter(cache => cache.status === 'completed' || cache.status === 'failed');
-    await CacheModel.destroy({
-        where: {
-            id: {
-                [Op.in]: toRemoveCaches.map(cache => cache.id)
-            }
-        }
-    });
-    return result;
-}
-
 function getRefreshedJwtTokenFromHeaders({ headers }) {
     if (!headers) {
         return null;
@@ -201,7 +178,6 @@ async function unregisterPluginAccount({ pluginId, rcAccountId }) {
 exports.getPluginsFromRcAccountId = getPluginsFromRcAccountId;
 exports.getPluginConfigFromUserSettings = getPluginConfigFromUserSettings;
 exports.getPluginLicenseStatus = getPluginLicenseStatus;
-exports.getPluginAsyncTasks = getPluginAsyncTasks;
 exports.getRefreshedJwtTokenFromHeaders = getRefreshedJwtTokenFromHeaders;
 exports.resolvePluginManifest = resolvePluginManifest;
 exports.persistPluginData = persistPluginData;

package/handlers/user.js

@@ -4,6 +4,83 @@ const { getHashValue } = require('../lib/util');
 const connectorRegistry = require('../connector/registry');
 const logger = require('../lib/logger');
 const { handleDatabaseError } = require('../lib/errorHandler');
+const { UserModel } = require('../models/userModel');
+const { handleApiError } = require('../lib/errorHandler');
+const oauth = require('../lib/oauth');
+const { Connector } = require('../models/dynamo/connectorSchema');
+
+async function refreshUserInfo({ platform, userId, tracer }) {
+    tracer?.trace('refreshUserInfo:start', { platform, userId });
+    try {
+        let user = await UserModel.findOne({
+            where: {
+                id: userId,
+                platform
+            }
+        });
+        tracer?.trace('refreshUserInfo:userFound', { user });
+
+        if (!user || !user.accessToken) {
+            tracer?.trace('refreshUserInfo:noUser', { userId });
+            return {
+                successful: false,
+                returnMessage: {
+                    message: `User not found`,
+                    messageType: 'warning',
+                    ttl: 5000
+                }
+            };
+        }
+
+        const proxyId = user.platformAdditionalInfo?.proxyId;
+        let proxyConfig = null;
+        if (proxyId) {
+            proxyConfig = await Connector.getProxyConfig(proxyId);
+            tracer?.trace('refreshUserInfo:proxyConfig', { proxyConfig });
+        }
+
+        const platformModule = connectorRegistry.getConnector(platform);
+        const authType = await platformModule.getAuthType({ proxyId, proxyConfig });
+        tracer?.trace('refreshUserInfo:authType', { authType });
+
+        let authHeader = '';
+        switch (authType) {
+            case 'oauth':
+                const oauthApp = oauth.getOAuthApp((await platformModule.getOauthInfo({ tokenUrl: user?.platformAdditionalInfo?.tokenUrl, hostname: user?.hostname, proxyId, proxyConfig })));
+                user = await oauth.checkAndRefreshAccessToken(oauthApp, user);
+                if (!user) {
+                    return {
+                        successful: false,
+                        returnMessage: {
+                            message: `User session expired. Please connect again.`,
+                            messageType: 'warning',
+                            ttl: 5000
+                        },
+                        isRevokeUserSession: true
+                    }
+                }
+                authHeader = `Bearer ${user.accessToken}`;
+                tracer?.trace('refreshUserInfo:oauthAuth', { authHeader });
+                break;
+            case 'apiKey':
+                const basicAuth = platformModule.getBasicAuth({ apiKey: user.accessToken });
+                authHeader = `Basic ${basicAuth}`;
+                tracer?.trace('refreshUserInfo:apiKeyAuth', {});
+                break;
+        }
+
+        const { successful, returnMessage } = await platformModule.refreshUserInfo({ user, authHeader, proxyConfig });
+        tracer?.trace('refreshUserInfo:platformRefreshResult', { successful, returnMessage });
+        return {
+            successful,
+            returnMessage
+        };
+    }
+    catch (e) {
+        tracer?.traceError('refreshUserInfo:error', e, { platform, userId });
+        return handleApiError(e, platform, 'refreshUserInfo', { userId });
+    }
+}
 
 async function getUserSettingsByAdmin({ rcAccessToken, rcAccountId }) {
     let hashedRcAccountId = null;
@@ -63,22 +140,31 @@ async function getUserSettings({ user, rcAccessToken, rcAccountId }) {
                     // Special case: plugins
                     if (key.startsWith('plugin_')) {
                         const config = Object.keys(result[key].value.config)?.length === 0 ? null : result[key].value.config;
+                        const configFromAdminSettings = userSettingsByAdmin.userSettings[key]?.value?.config ?? null;
                         if (config) {
-                            const configFromadminSettings = userSettingsByAdmin.userSettings[key].value.config ?? {};
-                            for (const k in config) {
-                                // use admin setting to replace, if not customizable
-                                if (configFromadminSettings[k] && !configFromadminSettings[k].customizable || !config[k].value && configFromadminSettings[k].value) {
-                                    config[k] = configFromadminSettings[k];
-                                }
-                                else {
-                                    config[k].customizable = configFromadminSettings[k]?.customizable ?? true;
+                            if (configFromAdminSettings) {
+                                for (const k in config) {
+                                    // use admin setting to replace, if not customizable
+                                    if (configFromAdminSettings[k] && !configFromAdminSettings[k].customizable || !config[k].value && configFromAdminSettings[k].value) {
+                                        config[k] = configFromAdminSettings[k];
+                                    }
+                                    else {
+                                        config[k].customizable = configFromAdminSettings[k]?.customizable ?? true;
+                                    }
                                 }
                             }
                             result[key].value.config = config;
                         }
                         //Case: no config at all, use admin setting directly
                         else {
-                            result[key].value.config = userSettingsByAdmin.userSettings[key].value.config;
+                            if (configFromAdminSettings) {
+                                result[key].value.config = {
+                                    ...configFromAdminSettings
+                                };
+                            }
+                            else {
+                                delete result[key];
+                            }
                         }
                     }
                 }
@@ -138,6 +224,7 @@ async function updateUserSettings({ user, userSettings, settingKeysToRemove, pla
     };
 }
 
+exports.refreshUserInfo = refreshUserInfo;
 exports.getUserSettingsByAdmin = getUserSettingsByAdmin;
 exports.getUserSettings = getUserSettings;
 exports.updateUserSettings = updateUserSettings;

package/index.js

@@ -260,6 +260,7 @@ function createCoreRouter() {
                 result.getUserList = !!platformModule.getUserList;
                 result.getLicenseStatus = !!platformModule.getLicenseStatus;
                 result.getLogFormatType = !!platformModule.getLogFormatType;
+                result.refreshUserInfo = !!platformModule.refreshUserInfo;
                 result.cacheCallNote = !!process.env.USE_CACHE;
                 res.status(200).send(tracer ? tracer.wrapResponse(result) : result);
             }
@@ -984,6 +985,49 @@ function createCoreRouter() {
         }
     }
     );
+    router.post('/user/refreshInfo', async function (req, res) {
+        const requestStartTime = new Date().getTime();
+        const tracer = req.headers['is-debug'] === 'true' ? DebugTracer.fromRequest(req) : null;
+        tracer?.trace('refreshUserInfo:start', { body: req.body });
+        let platformName = null;
+        let success = false;
+        const { hashedExtensionId, hashedAccountId, userAgent, ip, author, eventAddedVia } = getAnalyticsVariablesInReqHeaders({ headers: req.headers })
+        try {
+            const jwtToken = req.jwtToken || req.query.jwtToken;
+            if (jwtToken) {
+                const unAuthData = jwt.decodeJwt(jwtToken);
+                platformName = unAuthData?.platform ?? 'Unknown';
+                const userId = unAuthData?.id;
+                const { successful, returnMessage } = await userCore.refreshUserInfo({ platform: platformName, userId, tracer });
+                res.status(200).send(tracer ? tracer.wrapResponse({ successful, returnMessage }) : { successful, returnMessage });
+                success = true;
+            }
+            else {
+                tracer?.trace('refreshUserInfo:noToken', {});
+                res.status(400).send(tracer ? tracer.wrapResponse('Please go to Settings and authorize CRM platform') : 'Please go to Settings and authorize CRM platform');
+                success = false;
+            }
+        }
+        catch (e) {
+            logger.error('Refresh user info failed', { platform: platformName, stack: e.stack });
+            tracer?.traceError('refreshUserInfo:error', e, { platform: platformName });
+            res.status(400).send(tracer ? tracer.wrapResponse({ error: e.message || e }) : { error: e.message || e });
+        }
+        const requestEndTime = new Date().getTime();
+        analytics.track({
+            eventName: 'Refresh user info',
+            interfaceName: 'refreshUserInfo',
+            connectorName: platformName,
+            accountId: hashedAccountId,
+            extensionId: hashedExtensionId,
+            success,
+            requestDuration: (requestEndTime - requestStartTime) / 1000,
+            userAgent,
+            ip,
+            author,
+            eventAddedVia
+        });
+    })
     router.get('/user/settings', async function (req, res) {
         const requestStartTime = new Date().getTime();
         const tracer = req.headers['is-debug'] === 'true' ? DebugTracer.fromRequest(req) : null;
@@ -2053,7 +2097,7 @@ function createCoreRouter() {
                 }
                 const { id: userId, platform } = decodedToken;
                 platformName = platform;
-                const { successful, logId, returnMessage, extraDataTracking, pluginAsyncTaskIds, isRevokeUserSession } = await logCore.createCallLog({ jwtToken, platform, userId, incomingData: req.body, hashedAccountId: hashedAccountId ?? util.getHashValue(req.body.logInfo?.accountId, process.env.HASH_KEY), isFromSSCL: userAgent === 'SSCL' });
+                const { successful, logId, returnMessage, extraDataTracking, isRevokeUserSession } = await logCore.createCallLog({ jwtToken, platform, userId, incomingData: req.body, hashedAccountId: hashedAccountId ?? util.getHashValue(req.body.logInfo?.accountId, process.env.HASH_KEY), isFromSSCL: userAgent === 'SSCL' });
                 if (isRevokeUserSession) {
                     res.status(401).send(tracer ? tracer.wrapResponse({ successful, returnMessage }) : { successful, returnMessage });
                     success = false;
@@ -2062,7 +2106,7 @@ function createCoreRouter() {
                     if (extraDataTracking) {
                         extraData = extraDataTracking;
                     }
-                    res.status(200).send(tracer ? tracer.wrapResponse({ successful, logId, returnMessage, pluginAsyncTaskIds }) : { successful, logId, returnMessage, pluginAsyncTaskIds });
+                    res.status(200).send(tracer ? tracer.wrapResponse({ successful, logId, returnMessage }) : { successful, logId, returnMessage });
                     success = true;
                 }
             }
@@ -2116,11 +2160,11 @@ function createCoreRouter() {
                 }
                 const { id: userId, platform } = decodedToken;
                 platformName = platform;
-                const { successful, logId, updatedNote, returnMessage, extraDataTracking, pluginAsyncTaskIds } = await logCore.updateCallLog({ jwtToken, platform, userId, incomingData: req.body, hashedAccountId: hashedAccountId ?? util.getHashValue(req.body.accountId, process.env.HASH_KEY), isFromSSCL: userAgent === 'SSCL' });
+                const { successful, logId, updatedNote, returnMessage, extraDataTracking } = await logCore.updateCallLog({ jwtToken, platform, userId, incomingData: req.body, hashedAccountId: hashedAccountId ?? util.getHashValue(req.body.accountId, process.env.HASH_KEY), isFromSSCL: userAgent === 'SSCL' });
                 if (extraDataTracking) {
                     extraData = extraDataTracking;
                 }
-                res.status(200).send(tracer ? tracer.wrapResponse({ successful, logId, updatedNote, returnMessage, pluginAsyncTaskIds }) : { successful, logId, updatedNote, returnMessage, pluginAsyncTaskIds });
+                res.status(200).send(tracer ? tracer.wrapResponse({ successful, logId, updatedNote, returnMessage }) : { successful, logId, updatedNote, returnMessage });
                 success = true;
             }
             else {
@@ -2685,53 +2729,21 @@ function createCoreRouter() {
         });
     });
 
-    router.post('/pluginAsyncTask', async function (req, res) {
-        const requestStartTime = new Date().getTime();
+    router.post('/plugin/async-callback/:taskId', async function (req, res) {
         const tracer = req.headers['is-debug'] === 'true' ? DebugTracer.fromRequest(req) : null;
-        tracer?.trace('pluginAsyncTask:start', { query: req.query });
-        let platformName = null;
-        let success = false;
-        const { hashedExtensionId, hashedAccountId, userAgent, ip, author, eventAddedVia } = getAnalyticsVariablesInReqHeaders({ headers: req.headers })
-        const jwtToken = req.jwtToken || req.query.jwtToken;
+        tracer?.trace('pluginAsyncCallback:start', { taskId: req.params.taskId, body: req.body });
         try {
-            if (!jwtToken) {
-                tracer?.trace('pluginAsyncTask:noToken', {});
-                res.status(400).send(tracer ? tracer.wrapResponse('Please go to Settings and authorize CRM platform') : 'Please go to Settings and authorize CRM platform');
-                return;
-            }
-            const unAuthData = jwt.decodeJwt(jwtToken);
-            const user = await UserModel.findByPk(unAuthData?.id);
-            if (!user) {
-                tracer?.trace('pluginAsyncTask:userNotFound', {});
-                res.status(400).send(tracer ? tracer.wrapResponse('User not found') : 'User not found');
-                return;
-            }
-            const { asyncTaskIds } = req.body;
-            const filteredTasksIds = asyncTaskIds.filter(taskId => taskId.startsWith(user.id));
-            const tasks = await pluginCore.getPluginAsyncTasks({ asyncTaskIds: filteredTasksIds });
-            res.status(200).send(tracer ? tracer.wrapResponse({ tasks }) : { tasks });
-            success = true;
+            const result = await logCore.handleAsyncPluginCallback({
+                taskId: req.params.taskId,
+                body: req.body || {},
+            });
+            res.status(result.statusCode).send(tracer ? tracer.wrapResponse(result.body) : result.body);
         }
         catch (e) {
-            console.log(`platform: ${platformName} \n${e.stack}`);
-            res.status(400).send(tracer ? tracer.wrapResponse({ error: e.message || e }) : { error: e.message || e });
-            tracer?.traceError('pluginAsyncTask:error', e, { platform: platformName });
-            success = false;
+            logger.error('Plugin async callback failed', { taskId: req.params.taskId, stack: e.stack });
+            tracer?.traceError('pluginAsyncCallback:error', e);
+            res.status(500).send(tracer ? tracer.wrapResponse({ successful: false, message: e.message || e }) : { successful: false, message: e.message || e });
         }
-        const requestEndTime = new Date().getTime();
-        analytics.track({
-            eventName: 'Plugin Async Task',
-            interfaceName: 'pluginAsyncTask',
-            connectorName: platformName,
-            accountId: hashedAccountId,
-            extensionId: hashedExtensionId,
-            success,
-            requestDuration: (requestEndTime - requestStartTime) / 1000,
-            userAgent,
-            ip,
-            author,
-            eventAddedVia
-        });
     });
 
     router.post('/plugin/register', async function (req, res) {

package/mcp/README.md

@@ -62,11 +62,13 @@ A stateless, hand-rolled JSON-RPC handler — no `@modelcontextprotocol/sdk`, no
 **Key Features:**
 - Defines `WIDGET_VERSION` — the **single source of truth** for the widget cache-busting URI
 - Handles `initialize`, `tools/list`, `tools/call`, `resources/list`, `resources/read`, and `ping` methods
+- Defines `outputSchema` (JSON Schema) for AI-visible tools so clients can understand and validate structured results
 - Defines `inputSchema` (JSON Schema) for every tool that takes parameters — required so ChatGPT forwards arguments
 - Injects `rcAccessToken`, `openaiSessionId`, and `rcExtensionId` into every `tools/call` request
 - Verifies the RC access token against the RC API and caches `rcExtensionId` in `CacheModel` keyed by `openaiSessionId` (24h TTL) — subsequent requests hit the cache instead of the RC API
 - Automatically looks up and injects `jwtToken` from `LlmSessionModel` using `rcExtensionId` (or `openaiSessionId` as a fallback), only when the linked `User` row still has a CRM `accessToken`
 - Stamps `WIDGET_URI` into `getPublicConnectors`'s `_meta['openai/outputTemplate']` at response time
+- Returns `structuredContent` for schema-bearing tool calls and includes serialized JSON text content for backwards compatibility
 - Serves the widget HTML via `resources/read`
 - Exposes `handleWidgetToolCall` which searches both `tools.tools` and `tools.widgetTools`
 
@@ -127,6 +129,12 @@ New or refreshed LLM session JWTs are written only when the user record has an `
 
 Note: `widgetTools` are called via `POST /mcp/widget-tool-call` which bypasses the MCP session layer entirely. No server-side injection occurs for widget tool calls — all required values must be passed explicitly by the widget in the request body.
 
+### Output Handling
+
+`tools/list` includes an `outputSchema` for every AI-visible MCP tool. For `tools/call`, `mcpHandler.js` converts each tool's returned object into MCP `structuredContent` and also returns the same payload as serialized JSON in a text content block for clients that still read only `content`.
+
+Tools that return `{ success: false, ... }` are surfaced as regular MCP tool results with `isError: true`, so the model can see the error payload and self-correct.
+
 ### AI-Visible Tools (`tools`)
 
 #### `getHelp`

package/mcp/mcpHandler.js

@@ -85,6 +85,95 @@ const inputSchemas = {
     },
 };
 
+const standardToolResultOutputSchema = {
+    type: 'object',
+    properties: {
+        success: { type: 'boolean', description: 'Whether the tool operation completed successfully.' },
+        data: { description: 'Tool-specific successful result payload.' },
+        error: { type: 'string', description: 'Error message when the operation fails.' },
+        errorDetails: { type: 'string', description: 'Diagnostic details for troubleshooting.' },
+        message: { type: 'string', description: 'Human-readable status message.' },
+    },
+    required: ['success'],
+};
+
+/**
+ * JSON Schema definitions for each tool's structuredContent response.
+ * MCP clients use this from tools/list to understand and validate tool output.
+ */
+const outputSchemas = {
+    getHelp: {
+        type: 'object',
+        properties: {
+            success: { type: 'boolean' },
+            data: {
+                type: 'object',
+                properties: {
+                    overview: { type: 'string' },
+                    steps: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                },
+                required: ['overview', 'steps'],
+            },
+        },
+        required: ['success', 'data'],
+    },
+    getPublicConnectors: {
+        type: 'object',
+        properties: {
+            serverUrl: { type: 'string', description: 'Base URL for widget-to-server tool calls.' },
+            rcExtensionId: { description: 'Resolved RingCentral extension ID, or null when unavailable.' },
+            rcAccountId: { description: 'Resolved RingCentral account ID, or null when unavailable.' },
+            openaiSessionId: { description: 'OpenAI conversation session ID, or null when unavailable.' },
+            error: { type: 'boolean', description: 'Whether connector selection is blocked.' },
+            errorMessage: { type: 'string', description: 'Reason connector selection is blocked.' },
+        },
+    },
+    getSessionInfo: {
+        type: 'object',
+        properties: {
+            success: { type: 'boolean' },
+            data: {
+                type: 'object',
+                properties: {
+                    openaiSessionId: { description: 'OpenAI conversation session ID, or null when unavailable.' },
+                    dataToShow: {
+                        type: 'object',
+                        description: 'Non-sensitive session status for the current RingCentral and CRM connection.',
+                    },
+                },
+            },
+            error: { type: 'string' },
+            errorDetails: { type: 'string' },
+        },
+        required: ['success'],
+    },
+    rcGetCallLogs: {
+        type: 'object',
+        properties: {
+            records: {
+                type: 'array',
+                description: 'RingCentral call log records.',
+                items: { type: 'object' },
+            },
+            success: { type: 'boolean', description: 'False when fetching call logs fails.' },
+            error: { type: 'string', description: 'Error message when fetching call logs fails.' },
+        },
+    },
+    logout: standardToolResultOutputSchema,
+    findContactByPhone: standardToolResultOutputSchema,
+    findContactByName: standardToolResultOutputSchema,
+    createContact: standardToolResultOutputSchema,
+    createCallLog: standardToolResultOutputSchema,
+    listAppointments: standardToolResultOutputSchema,
+    createAppointment: standardToolResultOutputSchema,
+    updateAppointment: standardToolResultOutputSchema,
+    confirmAppointment: standardToolResultOutputSchema,
+    cancelAppointment: standardToolResultOutputSchema,
+};
+
 /**
  * Verify an RC access token and return the caller's extension ID.
  * Throws if the token is invalid.
@@ -138,7 +227,7 @@ async function resolveSessionContext(rcAccessToken, openaiSessionId) {
 
 /**
  * Build the tools list to return in tools/list responses.
- * Injects inputSchema and stamps WIDGET_URI into getPublicConnectors _meta.
+ * Injects schema metadata and stamps WIDGET_URI into getPublicConnectors _meta.
  */
 function getToolsList() {
     return tools.tools.map(tool => {
@@ -149,10 +238,41 @@ function getToolsList() {
         if (inputSchemas[def.name]) {
             def.inputSchema = inputSchemas[def.name];
         }
+        if (outputSchemas[def.name]) {
+            def.outputSchema = outputSchemas[def.name];
+        }
         return def;
     });
 }
 
+function getStructuredContent(result) {
+    if (result?.structuredContent && typeof result.structuredContent === 'object' && !Array.isArray(result.structuredContent)) {
+        return result.structuredContent;
+    }
+    if (result && typeof result === 'object' && !Array.isArray(result)) {
+        return result;
+    }
+    return { result: result ?? null };
+}
+
+function buildToolResult(toolDefinition, result) {
+    const structuredContent = getStructuredContent(result);
+    const responseResult = {
+        content: Array.isArray(result?.content)
+            ? result.content
+            : [{ type: 'text', text: JSON.stringify(structuredContent, null, 2) }],
+    };
+
+    if (toolDefinition?.outputSchema || outputSchemas[toolDefinition?.name] || result?.structuredContent) {
+        responseResult.structuredContent = structuredContent;
+    }
+    if (structuredContent?.success === false) {
+        responseResult.isError = true;
+    }
+
+    return responseResult;
+}
+
 /**
  * Handle incoming MCP HTTP requests.
  * Stateless: each POST is handled independently with no session state between requests.
@@ -265,26 +385,11 @@ async function handleMcpRequest(req, res) {
 
                     const result = await tool.execute(toolArgs);
 
-                    if (result?.structuredContent) {
-                        response = {
-                            jsonrpc: '2.0',
-                            id,
-                            result: {
-                                structuredContent: result.structuredContent,
-                                content: Array.isArray(result.content)
-                                    ? result.content
-                                    : [{ type: 'text', text: '[Interactive widget displayed above - no additional response needed]' }],
-                            },
-                        };
-                    } else {
-                        response = {
-                            jsonrpc: '2.0',
-                            id,
-                            result: {
-                                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                            },
-                        };
-                    }
+                    response = {
+                        jsonrpc: '2.0',
+                        id,
+                        result: buildToolResult(tool.definition, result),
+                    };
                 } catch (toolError) {
                     response = {
                         jsonrpc: '2.0',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@app-connect/core",
-  "version": "1.7.32",
+  "version": "1.7.33",
   "description": "RingCentral App Connect Core",
   "main": "index.js",
   "repository": {

package/releaseNotes.json

@@ -1,4 +1,28 @@
 {
+    "1.7.33": {
+        "global": [
+            {
+                "type": "New",
+                "description": "Developer Console manifest flag to disable Contact Cache"
+            },
+            {
+                "type": "New",
+                "description": "Interface refreshUserInfo, called when user opens extension"
+            },
+            {
+                "type": "New",
+                "description": "Async plugin callback"
+            },
+            {
+                "type": "New",
+                "description": "Developer Console manifest flag to hide plugin config fields"
+            },
+            {
+                "type": "Fix",
+                "description": "Mark outbound call on answer call pop option deprecated"
+            }
+        ]
+    },
     "1.7.30": {
         "global": [
             {