@webex/internal-plugin-ai-assistant 0.0.0-next.1

package/.eslintrc.js

@@ -0,0 +1,6 @@
+const config = {
+  root: true,
+  extends: ['@webex/eslint-config-legacy'],
+};
+
+module.exports = config;

package/README.md

@@ -0,0 +1,157 @@
+# @webex/internal-plugin-ai-assistant
+
+[![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+
+> Plugin for AI Assistant functionality
+
+This is an internal Cisco Webex plugin. As such, it does not strictly adhere to semantic versioning. Use at your own risk. If you're not working on one of our first party clients, please look at our [developer api](https://developer.webex.com/) and stick to our public plugins.
+
+- [Install](#install)
+- [Usage](#usage)
+- [Maintainers](#maintainers)
+- [Contribute](#contribute)
+- [License](#license)
+
+## Install
+
+```bash
+npm install --save @webex/internal-plugin-ai-assistant
+```
+
+## Usage
+
+The responses from the AI assistant service are delivered asynchronously via mercury. The methods in this plugin return a stream ID which can then be used to listen to the updates for a given request. The service will return preliminary versions of a response. The latest response for a given request should be used.
+
+The data used for the arguments to the methods in this plugin is obtained from either Locus or the Meeting Container.
+```js
+import '@webex/internal-plugin-ai-assistant';
+
+import WebexCore from '@webex/webex-core';
+
+const webex = new WebexCore();
+
+// Namespace.
+webex.internal.aiAssistant
+
+// Register the plugin (connects to mercury).
+webex.internal.aiAssistant.register()
+  .then(() => {}) // On successful registration.
+  .catch(() => {}); // On failed registration.
+
+// Unregister the plugin (disconnects from mercury).
+webex.internal.aiAssistant.unregister()
+  .then(() => {}) // On successful unregistration.
+  .catch(() => {}); // On failed unregistration.
+
+// Methods
+
+// Get a summary of a meeting
+webex.internal.aiAssistant.summarizeMeeting({
+  meetingInstanceId: '<meeting-instance-id>',
+  meetingSite: 'company.webex.com',
+  sessionId: '<session-id>', // Optional for first request
+  encryptionKeyUrl: '<encryption-key-url>',
+  lastMinutes: 30 // Optional: summarize only last 30 minutes
+}).then((response) => {
+  const { requestId, sessionId, streamEventName } = response;
+  
+  // Listen for streaming responses
+  webex.internal.aiAssistant.on(streamEventName, (data) => {
+    console.log('AI Response:', data.message);
+    if (data.finished) {
+      console.log('Summary complete');
+    }
+  });
+});
+
+// Check if your name was mentioned in a meeting
+webex.internal.aiAssistant.wasMyNameMentioned({
+  meetingInstanceId: '<meeting-instance-id>',
+  meetingSite: 'company.webex.com',
+  sessionId: '<session-id>', // Optional for first request
+  encryptionKeyUrl: '<encryption-key-url>'
+}).then((response) => {
+  const { requestId, sessionId, streamEventName } = response;
+  
+  // Listen for streaming responses
+  webex.internal.aiAssistant.on(streamEventName, (data) => {
+    console.log('Mention check result:', data.message);
+    if (data.finished) {
+      console.log('Check complete');
+    }
+  });
+});
+
+// Get all action items from a meeting
+webex.internal.aiAssistant.showAllActionItems({
+  meetingInstanceId: '<meeting-instance-id>',
+  meetingSite: 'company.webex.com',
+  sessionId: '<session-id>', // Optional for first request
+  encryptionKeyUrl: '<encryption-key-url>'
+}).then((response) => {
+  const { requestId, sessionId, streamEventName } = response;
+  
+  // Listen for streaming responses
+  webex.internal.aiAssistant.on(streamEventName, (data) => {
+    console.log('Action items:', data.message);
+    if (data.finished) {
+      console.log('Action items retrieval complete');
+    }
+  });
+});
+
+// Ask any question about the meeting content
+webex.internal.aiAssistant.askMeAnything({
+  meetingInstanceId: '<meeting-instance-id>',
+  meetingSite: 'company.webex.com',
+  sessionId: '<session-id>', // Optional for first request
+  encryptionKeyUrl: '<encryption-key-url>',
+  question: 'What were the main decisions made in this meeting?'
+}).then((response) => {
+  const { requestId, sessionId, streamEventName } = response;
+  
+  // Listen for streaming responses
+  webex.internal.aiAssistant.on(streamEventName, (data) => {
+    console.log('AI Answer:', data.message);
+    if (data.finished) {
+      console.log('Question answered');
+    }
+    if (data.errorMessage) {
+      console.error('Error:', data.errorMessage);
+    }
+  });
+});
+```
+
+### Response Format
+
+All AI Assistant methods return a Promise that resolves with:
+- `requestId`: Unique identifier for the request
+- `sessionId`: Session identifier for maintaining conversation context
+- `streamEventName`: Event name to listen for streaming responses
+
+### Stream Events
+
+Listen to the returned `streamEventName` for real-time AI responses:
+
+```js
+webex.internal.aiAssistant.on(streamEventName, (data) => {
+  console.log(data.message);     // Current message content
+  console.log(data.finished);    // Boolean indicating if response is complete
+  console.log(data.requestId);   // Request identifier
+  console.log(data.errorMessage); // Error message if any
+  console.log(data.errorCode);   // Error code if any
+});
+```
+
+## Maintainers
+
+This package is maintained by [Cisco Webex for Developers](https://developer.webex.com/).
+
+## Contribute
+
+Pull requests welcome. Please see [CONTRIBUTING.md](https://github.com/webex/webex-js-sdk/blob/master/CONTRIBUTING.md) for more details.
+
+## License
+
+© 2016-2025 Cisco and/or its affiliates. All Rights Reserved.

package/babel.config.js

@@ -0,0 +1,3 @@
+const babelConfigLegacy = require('@webex/babel-config-legacy');
+
+module.exports = babelConfigLegacy;

package/dist/ai-assistant.js

@@ -0,0 +1,491 @@
+"use strict";
+
+var _Object$keys = require("@babel/runtime-corejs2/core-js/object/keys");
+var _Object$getOwnPropertySymbols = require("@babel/runtime-corejs2/core-js/object/get-own-property-symbols");
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
+var _Object$getOwnPropertyDescriptors = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptors");
+var _Object$defineProperties = require("@babel/runtime-corejs2/core-js/object/define-properties");
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
+var _apply = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/reflect/apply"));
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
+var _uuid = _interopRequireDefault(require("uuid"));
+var _webexCore = require("@webex/webex-core");
+require("@webex/internal-plugin-mercury");
+var _lodash = require("lodash");
+var _commonTimers = require("@webex/common-timers");
+var _constants = require("./constants");
+function ownKeys(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; } /*!
+ * Copyright (c) 2015-2022 Cisco Systems, Inc. See LICENSE file.
+ */
+var AIAssistant = _webexCore.WebexPlugin.extend({
+  namespace: 'AIAssistant',
+  /**
+   * registered value indicating events registration is successful
+   * @instance
+   * @type {Boolean}
+   * @memberof AIAssistant
+   */
+  registered: false,
+  /**
+   * Initializer
+   * @private
+   * @param {Object} attrs
+   * @param {Object} options
+   * @returns {undefined}
+   */
+  initialize: function initialize() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    (0, _apply.default)(_webexCore.WebexPlugin.prototype.initialize, this, args);
+  },
+  /**
+   * Explicitly sets up the AI assistant plugin by connecting to mercury, and listening for AI assistant events.
+   * @returns {Promise}
+   * @public
+   * @memberof AIAssistant
+   */
+  register: function register() {
+    var _this = this;
+    if (!this.webex.canAuthorize) {
+      this.logger.error('AI assistant->register#ERROR, Unable to register, SDK cannot authorize');
+      return _promise.default.reject(new Error('SDK cannot authorize'));
+    }
+    if (this.registered) {
+      this.logger.info('AI assistant->register#INFO, AI assistant plugin already registered');
+      return _promise.default.resolve();
+    }
+    return this.webex.internal.mercury.connect().then(function () {
+      _this.listenForEvents();
+      _this.trigger(_constants.AI_ASSISTANT_REGISTERED);
+      _this.registered = true;
+    }).catch(function (error) {
+      _this.logger.error("AI assistant->register#ERROR, Unable to register, ".concat(error.message));
+      return _promise.default.reject(error);
+    });
+  },
+  /**
+   * Explicitly tears down the AI assistant plugin by disconnecting from mercury, and stops listening to AI assistant events
+   * @returns {Promise}
+   * @public
+   * @memberof AIAssistant
+   */
+  unregister: function unregister() {
+    var _this2 = this;
+    if (!this.registered) {
+      this.logger.info('AI assistant->unregister#INFO, AI assistant plugin already unregistered');
+      return _promise.default.resolve();
+    }
+    this.stopListeningForEvents();
+    return this.webex.internal.mercury.disconnect().then(function () {
+      _this2.trigger(_constants.AI_ASSISTANT_UNREGISTERED);
+      _this2.registered = false;
+    });
+  },
+  /**
+   * registers for Assistant API events through mercury
+   * @returns {undefined}
+   * @private
+   */
+  listenForEvents: function listenForEvents() {
+    var _this3 = this;
+    this.webex.internal.mercury.on(_constants.ASSISTANT_API_RESPONSE_EVENT, function (envelope) {
+      _this3._handleEvent(envelope.data);
+    });
+  },
+  /**
+   * unregisteres all the Assistant API events from mercury
+   * @returns {undefined}
+   * @private
+   */
+  stopListeningForEvents: function stopListeningForEvents() {
+    this.webex.internal.mercury.off(_constants.ASSISTANT_API_RESPONSE_EVENT);
+  },
+  /**
+   * constructs the event name based on request id
+   * This is used by the plugin to listen for the result of a particular request
+   * @param {UUID} requestId the id of the request
+   * @returns {string}
+   */
+  _getResultEventName: function _getResultEventName(requestId) {
+    return "".concat(_constants.AI_ASSISTANT_RESULT, ":").concat(requestId);
+  },
+  /**
+   * constructs the stream event name based on request id
+   * This is used by the consumer to listen for the stream (i.e. the data) of a particular request
+   * @param {UUID} requestId the id of the request
+   * @returns {string}
+   */
+  _getStreamEventName: function _getStreamEventName(requestId) {
+    return "".concat(_constants.AI_ASSISTANT_STREAM, ":").concat(requestId);
+  },
+  /**
+   * Takes incoming data and triggers correct events
+   * @param {Object} data the event data
+   * @returns {undefined}
+   */
+  _handleEvent: function _handleEvent(data) {
+    this.trigger(this._getResultEventName(data.clientRequestId), data);
+  },
+  /**
+   * Decrypts the encrypted value using the encryption key URL
+   * @param {Object} options
+   * @param {string} options.value the encrypted value to decrypt
+   * @param {string} options.encryptionKeyUrl the encryption key URL to use for
+   * @returns {Promise<Object>} returns a promise that resolves with the decrypted value
+   */
+  _decryptData: function _decryptData(_ref) {
+    var _this4 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+      var value, encryptionKeyUrl, result;
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            value = _ref.value, encryptionKeyUrl = _ref.encryptionKeyUrl;
+            _context.next = 3;
+            return _this4.webex.internal.encryption.decryptText(encryptionKeyUrl, value);
+          case 3:
+            result = _context.sent;
+            return _context.abrupt("return", result);
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))();
+  },
+  /**
+   * Makes the request to the AI assistant service
+   * @param {Object} options
+   * @param {string} options.resource the URL to query
+   * @param {Mixed} options.params additional params for the body of the request
+   * @param {string} options.dataPath the path to get the data in the result object
+   * @returns {Promise<Object>} Resolves with an object containing the requestId, sessionId and streamEventName
+   */
+  _request: function _request(options) {
+    var _this5 = this;
+    var resource = options.resource,
+      params = options.params,
+      dataPath = options.dataPath;
+    var timeout = this.config.requestTimeout;
+    var requestId = _uuid.default.v4();
+    var eventName = this._getResultEventName(requestId);
+    var streamEventName = this._getStreamEventName(requestId);
+    var concatenatedMessage = '';
+
+    // eslint-disable-next-line no-async-promise-executor
+    return new _promise.default(function (resolve, reject) {
+      var timer = new _commonTimers.Timer(function () {
+        _this5.stopListening(_this5, eventName);
+        _this5.trigger(streamEventName, {
+          requestId: requestId,
+          finished: true,
+          errorMessage: _constants.AI_ASSISTANT_ERRORS.AI_ASSISTANT_TIMEOUT,
+          errorCode: _constants.AI_ASSISTANT_ERROR_CODES.AI_ASSISTANT_TIMEOUT
+        });
+      }, timeout);
+      _this5.listenTo(_this5, eventName, /*#__PURE__*/function () {
+        var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(data) {
+          var resultData, errorMessage, errorCode, decryptedMessage, _decryptedMessage;
+          return _regenerator.default.wrap(function _callee2$(_context2) {
+            while (1) switch (_context2.prev = _context2.next) {
+              case 0:
+                timer.reset();
+                resultData = (0, _lodash.get)(data, dataPath, []);
+                errorMessage = (0, _lodash.get)(data, 'response.errorMessage');
+                errorCode = (0, _lodash.get)(data, 'response.errorCode');
+                if (!data.finished) {
+                  _context2.next = 20;
+                  break;
+                }
+                // For finished messages, decrypt and emit the final complete message
+                timer.cancel();
+                _context2.prev = 6;
+                if (!(resultData !== null && resultData !== void 0 && resultData.value)) {
+                  _context2.next = 11;
+                  break;
+                }
+                _context2.next = 10;
+                return _this5._decryptData(resultData);
+              case 10:
+                decryptedMessage = _context2.sent;
+              case 11:
+                // Emit the final message
+                _this5.trigger(streamEventName, {
+                  message: decryptedMessage || '',
+                  requestId: requestId,
+                  finished: true,
+                  errorMessage: errorMessage,
+                  errorCode: errorCode
+                });
+                _this5.stopListening(_this5, eventName);
+                _context2.next = 18;
+                break;
+              case 15:
+                _context2.prev = 15;
+                _context2.t0 = _context2["catch"](6);
+                _this5.trigger(streamEventName, {
+                  message: concatenatedMessage,
+                  requestId: requestId,
+                  finished: true,
+                  errorMessage: errorMessage || _context2.t0.message,
+                  errorCode: errorCode
+                });
+              case 18:
+                _context2.next = 33;
+                break;
+              case 20:
+                _context2.prev = 20;
+                _decryptedMessage = '';
+                if (!(resultData !== null && resultData !== void 0 && resultData.value)) {
+                  _context2.next = 26;
+                  break;
+                }
+                _context2.next = 25;
+                return _this5._decryptData(resultData);
+              case 25:
+                _decryptedMessage = _context2.sent;
+              case 26:
+                concatenatedMessage += _decryptedMessage;
+
+                // Emit the concatenated message so far
+                _this5.trigger(streamEventName, {
+                  message: concatenatedMessage,
+                  requestId: requestId,
+                  finished: false,
+                  errorMessage: errorMessage,
+                  errorCode: errorCode
+                });
+                _context2.next = 33;
+                break;
+              case 30:
+                _context2.prev = 30;
+                _context2.t1 = _context2["catch"](20);
+                // If decryption fails, we still want to continue listening for more messages
+                _this5.trigger(streamEventName, {
+                  message: concatenatedMessage,
+                  requestId: requestId,
+                  finished: false,
+                  errorMessage: errorMessage || _context2.t1.message,
+                  errorCode: errorCode
+                });
+              case 33:
+              case "end":
+                return _context2.stop();
+            }
+          }, _callee2, null, [[6, 15], [20, 30]]);
+        }));
+        return function (_x) {
+          return _ref2.apply(this, arguments);
+        };
+      }());
+      _this5.webex.request({
+        service: _constants.AI_ASSISTANT_SERVICE_NAME,
+        resource: resource,
+        method: 'POST',
+        contentType: 'application/json',
+        body: _objectSpread({
+          clientRequestId: requestId
+        }, params)
+      }).catch(function (error) {
+        reject(error);
+      }).then(function (_ref3) {
+        var body = _ref3.body;
+        var sessionId = body.sessionId;
+        resolve({
+          requestId: requestId,
+          sessionId: sessionId,
+          streamEventName: streamEventName
+        });
+        timer.start();
+      });
+    });
+  },
+  /**
+   * Common method to make AI assistant requests for meeting analysis
+   * @param {Object} options
+   * @param {string} options.contextResources array of context resources to include in the request
+   * @param {string} options.sessionId the session ID for subsequent requests, not required for the first request
+   * @param {string} options.encryptionKeyUrl the encryption key URL for this meeting summary
+   * @param {string} options.contentType the type of content ('action' or 'message')
+   * @param {string} options.contentValue the value to use (action name or message text)
+   * @param {Object} options.parameters optional parameters to include in the request (for action type only)
+   * @param {Object} options.assistant optional parameter to specify the assistant to use
+   * @param {Object} options.locale optional locale to use for the request, defaults to 'en_US'
+   * @returns {Promise<Object>} Resolves with an object containing the requestId, sessionId and streamEventName
+   */
+  _makeMeetingRequest: function _makeMeetingRequest(options) {
+    var _this6 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+      var value, content;
+      return _regenerator.default.wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            value = options.contentValue;
+            if (!(options.contentType === 'message')) {
+              _context3.next = 5;
+              break;
+            }
+            _context3.next = 4;
+            return _this6._encryptData({
+              text: options.contentValue,
+              encryptionKeyUrl: options.encryptionKeyUrl
+            });
+          case 4:
+            value = _context3.sent;
+          case 5:
+            content = {
+              context: {
+                resources: options.contextResources
+              },
+              encryptionKeyUrl: options.encryptionKeyUrl,
+              type: options.contentType,
+              value: value
+            };
+            if (options.contentType === 'action' && options.parameters) {
+              content.parameters = options.parameters;
+            }
+            return _context3.abrupt("return", _this6._request({
+              resource: options.sessionId ? "sessions/".concat(options.sessionId, "/messages") : 'sessions/messages',
+              dataPath: 'response.content',
+              params: _objectSpread({
+                async: 'chunked',
+                locale: options.locale || 'en_US',
+                content: content
+              }, options.assistant ? {
+                assistant: options.assistant
+              } : {})
+            }));
+          case 8:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }))();
+  },
+  /**
+   * Returns the summary of a meeting
+   * @param {Object} options
+   * @param {string} options.meetingInstanceId the meeting instance ID for the meeting from locus
+   * @param {string} options.meetingSite the name.webex.com site for the meeting
+   * @param {string} options.sessionId the session ID for subsequent requests, not required for the first request
+   * @param {string} options.encryptionKeyUrl the encryption key URL for this meeting summary
+   * @param {number} options.lastMinutes Optional number of minutes to summarize from the end of the meeting. If not included, summarizes from the start.
+   * @returns {Promise<Object>} Resolves with an object containing the requestId, sessionId and streamEventName
+   */
+  summarizeMeeting: function summarizeMeeting(options) {
+    return this._makeMeetingRequest(_objectSpread(_objectSpread({}, options), {}, {
+      contentType: _constants.CONTENT_TYPES.ACTION,
+      contentValue: _constants.ACTION_TYPES.SUMMARIZE_FOR_ME,
+      contextResources: [{
+        id: options.meetingInstanceId,
+        type: _constants.CONTEXT_RESOURCE_TYPES.MEETING,
+        url: options.meetingSite
+      }]
+    }, options.lastMinutes ? {
+      parameters: {
+        lastMinutes: options.lastMinutes
+      }
+    } : {}));
+  },
+  /**
+   * Checks if the user's name was mentioned in a meeting
+   * @param {Object} options
+   * @param {string} options.meetingInstanceId the meeting instance ID for the meeting from locus
+   * @param {string} options.meetingSite the name.webex.com site for the meeting
+   * @param {string} options.sessionId the session ID for subsequent requests, not required for the first request
+   * @param {string} options.encryptionKeyUrl the encryption key URL for this meeting summary
+   * @returns {Promise<Object>} Resolves with an object containing the requestId, sessionId and streamEventName
+   */
+  wasMyNameMentioned: function wasMyNameMentioned(options) {
+    return this._makeMeetingRequest(_objectSpread(_objectSpread({}, options), {}, {
+      contextResources: [{
+        id: options.meetingInstanceId,
+        type: _constants.CONTEXT_RESOURCE_TYPES.MEETING,
+        url: options.meetingSite
+      }],
+      contentType: _constants.CONTENT_TYPES.ACTION,
+      contentValue: _constants.ACTION_TYPES.WAS_MY_NAME_MENTIONED
+    }));
+  },
+  /**
+   * Returns all action items from a meeting
+   * @param {Object} options
+   * @param {string} options.meetingInstanceId the meeting instance ID for the meeting from locus
+   * @param {string} options.meetingSite the name.webex.com site for the meeting
+   * @param {string} options.sessionId the session ID for subsequent requests, not required for the first request
+   * @param {string} options.encryptionKeyUrl the encryption key URL for this meeting summary
+   * @returns {Promise<Object>} Resolves with an object containing the requestId, sessionId and streamEventName
+   */
+  showAllActionItems: function showAllActionItems(options) {
+    return this._makeMeetingRequest(_objectSpread(_objectSpread({}, options), {}, {
+      contextResources: [{
+        id: options.meetingInstanceId,
+        type: _constants.CONTEXT_RESOURCE_TYPES.MEETING,
+        url: options.meetingSite
+      }],
+      contentType: _constants.CONTENT_TYPES.ACTION,
+      contentValue: _constants.ACTION_TYPES.SHOW_ALL_ACTION_ITEMS
+    }));
+  },
+  /**
+   * Helper method to encrypt text using the encryption key URL
+   * @param {Object} options
+   * @param {string} options.text the text to encrypt
+   * @param {string} options.encryptionKeyUrl the encryption key URL to use for encryption
+   * @returns {Promise<string>} returns a promise that resolves with the encrypted text
+   */
+  _encryptData: function _encryptData(_ref4) {
+    var _this7 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      var text, encryptionKeyUrl, result;
+      return _regenerator.default.wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            text = _ref4.text, encryptionKeyUrl = _ref4.encryptionKeyUrl;
+            _context4.next = 3;
+            return _this7.webex.internal.encryption.encryptText(encryptionKeyUrl, text);
+          case 3:
+            result = _context4.sent;
+            return _context4.abrupt("return", result);
+          case 5:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }))();
+  },
+  /**
+   * Ask any question about the meeting content
+   * @param {Object} options
+   * @param {string} options.meetingInstanceId the meeting instance ID for the meeting from locus
+   * @param {string} options.meetingSite the name.webex.com site for the meeting
+   * @param {string} options.sessionId the session ID for subsequent requests, not required for the first request
+   * @param {string} options.encryptionKeyUrl the encryption key URL for this meeting summary
+   * @param {string} options.question the question to ask about the meeting content
+   * @returns {Promise<Object>} Resolves with an object containing the requestId, sessionId and streamEventName
+   */
+  askMeAnything: function askMeAnything(options) {
+    return this._makeMeetingRequest(_objectSpread(_objectSpread({}, options), {}, {
+      contextResources: [{
+        id: options.meetingInstanceId,
+        type: _constants.CONTEXT_RESOURCE_TYPES.MEETING,
+        url: options.meetingSite
+      }],
+      contentType: _constants.CONTENT_TYPES.MESSAGE,
+      contentValue: options.question
+    }));
+  },
+  version: "0.0.0-next.1"
+});
+var _default = exports.default = AIAssistant;
+//# sourceMappingURL=ai-assistant.js.map