@webex/internal-plugin-llm 2.23.0

package/README.md

@@ -0,0 +1,55 @@
+# @webex/internal-plugin-llm
+
+[![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+
+> Plugin for the LLM service
+
+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.
+
+- [@webex/internal-plugin-llm](#webexinternal-plugin-llm)
+  - [Install](#install)
+  - [Usage](#usage)
+  - [Maintainers](#maintainers)
+  - [Contribute](#contribute)
+  - [License](#license)
+
+## Install
+
+```bash
+npm install --save @webex/internal-plugin-llm
+```
+
+## Usage
+
+```js
+
+import '@webex/internal-plugin-llm';
+
+import WebexCore from '@webex/webex-core';
+
+const webex = new WebexCore();
+// locusUrl is got from meeting.locusInfo.url;
+// datachannelUrl is got from meeting.locusInfo.info.datachannelUrl; 
+webex.internal.llm.registerAndConnect(locusUrl, datachannelUrl);
+
+// Checks if LLM is connected
+webex.internal.llm.isConnected();
+
+// Disconnect LLM connection
+webex.internal.llm.disconnectLLM();
+
+// Get Locus URL
+webex.internal.llm.getLocusUrl();
+```
+
+## 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-2022 Cisco and/or its affiliates. All Rights Reserved.

package/dist/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.LLM = void 0;
+// eslint-disable-next-line import/prefer-default-export
+var LLM = 'llm';
+exports.LLM = LLM;
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["LLM"],"sources":["constants.ts"],"sourcesContent":["// eslint-disable-next-line import/prefer-default-export\nexport const LLM = 'llm';\n"],"mappings":";;;;;;;;;AAAA;AACO,IAAMA,GAAG,GAAG,KAAZ"}

package/dist/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _typeof = require("@babel/runtime-corejs2/helpers/typeof");
+
+var _WeakMap = require("@babel/runtime-corejs2/core-js/weak-map");
+
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
+
+var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+_Object$defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _llm2.default;
+  }
+});
+
+var WebexCore = _interopRequireWildcard(require("@webex/webex-core"));
+
+var _llm = _interopRequireWildcard(require("@webex/internal-plugin-llm/src/llm"));
+
+var _llm2 = _interopRequireDefault(require("./llm"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof _WeakMap !== "function") return null; var cacheBabelInterop = new _WeakMap(); var cacheNodeInterop = new _WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = _Object$defineProperty && _Object$getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? _Object$getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { _Object$defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+WebexCore.registerInternalPlugin('llm', _llm.default, {
+  config: _llm.config
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WebexCore","registerInternalPlugin","LLMChannel","config"],"sources":["index.js"],"sourcesContent":["import * as WebexCore from '@webex/webex-core';\nimport LLMChannel, {config} from '@webex/internal-plugin-llm/src/llm';\n\nWebexCore.registerInternalPlugin('llm', LLMChannel, {\n  config,\n});\n\nexport {default} from './llm';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AAMA;;;;;;AAJAA,SAAS,CAACC,sBAAV,CAAiC,KAAjC,EAAwCC,YAAxC,EAAoD;EAClDC,MAAM,EAANA;AADkD,CAApD"}

package/dist/llm.js

@@ -0,0 +1,156 @@
+"use strict";
+
+var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
+
+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 = exports.config = void 0;
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+
+var _internalPluginMercury = _interopRequireDefault(require("@webex/internal-plugin-mercury"));
+
+var _constants = require("./constants");
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = _Reflect$construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !_Reflect$construct) return false; if (_Reflect$construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var config = {
+  llm: {
+    /**
+     * Milliseconds between pings sent up the socket
+     * @type {number}
+     */
+    pingInterval: process.env.MERCURY_PING_INTERVAL || 15000,
+
+    /**
+     * Milliseconds to wait for a pong before declaring the connection dead
+     * @type {number}
+     */
+    pongTimeout: process.env.MERCURY_PONG_TIMEOUT || 14000,
+
+    /**
+     * Maximum milliseconds between connection attempts
+     * @type {Number}
+     */
+    backoffTimeMax: process.env.MERCURY_BACKOFF_TIME_MAX || 32000,
+
+    /**
+     * Initial milliseconds between connection attempts
+     * @type {Number}
+     */
+    backoffTimeReset: process.env.MERCURY_BACKOFF_TIME_RESET || 1000,
+
+    /**
+     * Milliseconds to wait for a close frame before declaring the socket dead and
+     * discarding it
+     * @type {[type]}
+     */
+    forceCloseDelay: process.env.MERCURY_FORCE_CLOSE_DELAY || 2000
+  }
+};
+/**
+ * LLMChannel to provide socket connections
+ */
+
+exports.config = config;
+
+var LLMChannel = /*#__PURE__*/function (_ref) {
+  (0, _inherits2.default)(LLMChannel, _ref);
+
+  var _super = _createSuper(LLMChannel);
+
+  /**
+     * If the LLM plugin has been registered and listening
+     * @instance
+     * @type {Boolean}
+     * @public
+     */
+
+  /**
+   * Initializes the LLM Plugin
+   * @constructor
+   * @public
+   */
+  function LLMChannel() {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, LLMChannel);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    // eslint-disable-next-line constructor-super
+    _this = _super.call.apply(_super, [this].concat(args));
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "namespace", _constants.LLM);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "registered", false);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "webex", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "webSocketUrl", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "binding", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "locusUrl", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "register", function (llmSocketUrl) {
+      return _this.request({
+        method: 'POST',
+        url: llmSocketUrl
+      }).then(function (res) {
+        _this.webSocketUrl = res.body.webSocketUrl;
+        _this.binding = res.body.binding;
+      });
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "registerAndConnect", function (locusUrl, datachannelUrl) {
+      return _this.register(datachannelUrl).then(function () {
+        if (!locusUrl || !datachannelUrl) return undefined;
+        _this.locusUrl = locusUrl;
+
+        _this.connect(_this.webSocketUrl).then(function () {
+          _this.registered = true;
+        });
+      });
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "isConnected", function () {
+      return _this.registered;
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "getBinding", function () {
+      return _this.binding;
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "getLocusUrl", function () {
+      return _this.locusUrl;
+    });
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "disconnectLLM", function () {
+      return _this.disconnect();
+    });
+    _this.registered = false;
+    return _this;
+  }
+  /**
+   * Register to the websocket
+   * @param {string} llmSocketUrl
+   * @returns {Promise<void>}
+   */
+
+
+  return (0, _createClass2.default)(LLMChannel);
+}(_internalPluginMercury.default);
+
+exports.default = LLMChannel;
+//# sourceMappingURL=llm.js.map

package/dist/llm.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["config","llm","pingInterval","process","env","MERCURY_PING_INTERVAL","pongTimeout","MERCURY_PONG_TIMEOUT","backoffTimeMax","MERCURY_BACKOFF_TIME_MAX","backoffTimeReset","MERCURY_BACKOFF_TIME_RESET","forceCloseDelay","MERCURY_FORCE_CLOSE_DELAY","LLMChannel","args","LLM","llmSocketUrl","request","method","url","then","res","webSocketUrl","body","binding","locusUrl","datachannelUrl","register","undefined","connect","registered","disconnect","Mercury"],"sources":["llm.ts"],"sourcesContent":["import Mercury from '@webex/internal-plugin-mercury';\n\n\nimport {LLM} from './constants';\n// eslint-disable-next-line no-unused-vars\nimport {ILLMChannel} from './llm.types';\n\nexport const config = {\n  llm: {\n    /**\n     * Milliseconds between pings sent up the socket\n     * @type {number}\n     */\n    pingInterval: process.env.MERCURY_PING_INTERVAL || 15000,\n    /**\n     * Milliseconds to wait for a pong before declaring the connection dead\n     * @type {number}\n     */\n    pongTimeout: process.env.MERCURY_PONG_TIMEOUT || 14000,\n    /**\n     * Maximum milliseconds between connection attempts\n     * @type {Number}\n     */\n    backoffTimeMax: process.env.MERCURY_BACKOFF_TIME_MAX || 32000,\n    /**\n     * Initial milliseconds between connection attempts\n     * @type {Number}\n     */\n    backoffTimeReset: process.env.MERCURY_BACKOFF_TIME_RESET || 1000,\n    /**\n     * Milliseconds to wait for a close frame before declaring the socket dead and\n     * discarding it\n     * @type {[type]}\n     */\n    forceCloseDelay: process.env.MERCURY_FORCE_CLOSE_DELAY || 2000,\n  },\n};\n\n/**\n * LLMChannel to provide socket connections\n */\nexport default class LLMChannel extends (Mercury as any) implements ILLMChannel {\n  namespace = LLM;\n\n  /**\n     * If the LLM plugin has been registered and listening\n     * @instance\n     * @type {Boolean}\n     * @public\n     */\n  private registered:boolean = false;\n\n  public webex: any;\n\n  private webSocketUrl: string;\n\n  private binding: string;\n\n  private locusUrl: string;\n\n\n  /**\n   * Initializes the LLM Plugin\n   * @constructor\n   * @public\n   */\n  constructor(...args) {\n    // eslint-disable-next-line constructor-super\n    super(...args);\n\n\n    this.registered = false;\n  }\n\n  /**\n   * Register to the websocket\n   * @param {string} llmSocketUrl\n   * @returns {Promise<void>}\n   */\n  private register = (llmSocketUrl:string):Promise<void> => this.request({\n    method: 'POST',\n    url: llmSocketUrl,\n  }).then((res: { body: { webSocketUrl: string; binding: string; }; }) => {\n    this.webSocketUrl = res.body.webSocketUrl;\n    this.binding = res.body.binding;\n  });\n\n  /**\n   * Register and connect to the websocket\n   * @param {string} locusUrl\n   * @param {string} datachannelUrl\n   * @returns {Promise<void>}\n   */\n  public registerAndConnect = (locusUrl:string, datachannelUrl:string):Promise<void> => this.register(datachannelUrl).then(() => {\n    if(!locusUrl || !datachannelUrl) return undefined;\n    this.locusUrl = locusUrl;\n    this.connect(this.webSocketUrl).then(() => {\n      this.registered = true;\n    });\n  });\n\n  /**\n   * Tells if LLM socket is connected\n   * @returns {boolean} isRegistered\n   */\n  public isConnected = ():boolean => this.registered;\n\n  /**\n   * Tells if LLM socket is connected\n   * @returns {bool} isRegistered\n   */\n  public getBinding = ():string => this.binding;\n\n  /**\n   * Get Locus URL for the connection\n   * @returns {string} locus Url\n   */\n  public getLocusUrl = ():string => this.locusUrl;\n  /**\n   * Disconnects websocket connection\n   * @returns Promise<void>\n   */\n  public disconnectLLM = () => this.disconnect()\n}\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AAGA;;;;;;AAIO,IAAMA,MAAM,GAAG;EACpBC,GAAG,EAAE;IACH;AACJ;AACA;AACA;IACIC,YAAY,EAAEC,OAAO,CAACC,GAAR,CAAYC,qBAAZ,IAAqC,KALhD;;IAMH;AACJ;AACA;AACA;IACIC,WAAW,EAAEH,OAAO,CAACC,GAAR,CAAYG,oBAAZ,IAAoC,KAV9C;;IAWH;AACJ;AACA;AACA;IACIC,cAAc,EAAEL,OAAO,CAACC,GAAR,CAAYK,wBAAZ,IAAwC,KAfrD;;IAgBH;AACJ;AACA;AACA;IACIC,gBAAgB,EAAEP,OAAO,CAACC,GAAR,CAAYO,0BAAZ,IAA0C,IApBzD;;IAqBH;AACJ;AACA;AACA;AACA;IACIC,eAAe,EAAET,OAAO,CAACC,GAAR,CAAYS,yBAAZ,IAAyC;EA1BvD;AADe,CAAf;AA+BP;AACA;AACA;;;;IACqBC,U;;;;;EAGnB;AACF;AACA;AACA;AACA;AACA;;EAYE;AACF;AACA;AACA;AACA;EACE,sBAAqB;IAAA;;IAAA;;IAAA,kCAANC,IAAM;MAANA,IAAM;IAAA;;IACnB;IACA,gDAASA,IAAT;IAFmB,wFAxBTC,cAwBS;IAAA,yFAhBQ,KAgBR;IAAA;IAAA;IAAA;IAAA;IAAA,uFAaF,UAACC,YAAD;MAAA,OAAuC,MAAKC,OAAL,CAAa;QACrEC,MAAM,EAAE,MAD6D;QAErEC,GAAG,EAAEH;MAFgE,CAAb,EAGvDI,IAHuD,CAGlD,UAACC,GAAD,EAAgE;QACtE,MAAKC,YAAL,GAAoBD,GAAG,CAACE,IAAJ,CAASD,YAA7B;QACA,MAAKE,OAAL,GAAeH,GAAG,CAACE,IAAJ,CAASC,OAAxB;MACD,CANyD,CAAvC;IAAA,CAbE;IAAA,iGA2BO,UAACC,QAAD,EAAkBC,cAAlB;MAAA,OAA0D,MAAKC,QAAL,CAAcD,cAAd,EAA8BN,IAA9B,CAAmC,YAAM;QAC7H,IAAG,CAACK,QAAD,IAAa,CAACC,cAAjB,EAAiC,OAAOE,SAAP;QACjC,MAAKH,QAAL,GAAgBA,QAAhB;;QACA,MAAKI,OAAL,CAAa,MAAKP,YAAlB,EAAgCF,IAAhC,CAAqC,YAAM;UACzC,MAAKU,UAAL,GAAkB,IAAlB;QACD,CAFD;MAGD,CANqF,CAA1D;IAAA,CA3BP;IAAA,0FAuCA;MAAA,OAAc,MAAKA,UAAnB;IAAA,CAvCA;IAAA,yFA6CD;MAAA,OAAa,MAAKN,OAAlB;IAAA,CA7CC;IAAA,0FAmDA;MAAA,OAAa,MAAKC,QAAlB;IAAA,CAnDA;IAAA,4FAwDE;MAAA,OAAM,MAAKM,UAAL,EAAN;IAAA,CAxDF;IAKnB,MAAKD,UAAL,GAAkB,KAAlB;IALmB;EAMpB;EAED;AACF;AACA;AACA;AACA;;;;EArCyCE,8B"}

package/dist/llm.types.js

@@ -0,0 +1,8 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=llm.types.js.map

package/dist/llm.types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["llm.types.ts"],"sourcesContent":["\ninterface ILLMChannel{\n    registerAndConnect: (locusUrl:string, datachannelUrl:string) => Promise<void>;\n    isConnected: () => boolean;\n    getBinding: () => string;\n    getLocusUrl: () => string;\n    disconnectLLM: () => Promise<void>;\n}\n// eslint-disable-next-line import/prefer-default-export\nexport {ILLMChannel};\n"],"mappings":""}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@webex/internal-plugin-llm",
+  "version": "2.23.0",
+  "description": "",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "devMain": "src/index.js",
+  "repository": "https://github.com/webex/webex-js-sdk/tree/master/packages/node_modules/@webex/internal-plugin-llm",
+  "engines": {
+    "node": ">=8"
+  },
+  "dependencies": {
+    "@babel/runtime-corejs2": "^7.14.8",
+    "@webex/webex-core": "2.23.0",
+    "@webex/internal-plugin-llm": "2.23.0",
+    "@webex/internal-plugin-mercury": "2.23.0",
+    "envify": "^4.1.0"
+  },
+  "browserify": {
+    "transform": [
+      "envify"
+    ]
+  }
+}

package/src/constants.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/prefer-default-export
+export const LLM = 'llm';

package/src/index.js

@@ -0,0 +1,8 @@
+import * as WebexCore from '@webex/webex-core';
+import LLMChannel, {config} from '@webex/internal-plugin-llm/src/llm';
+
+WebexCore.registerInternalPlugin('llm', LLMChannel, {
+  config,
+});
+
+export {default} from './llm';

package/src/llm.ts

@@ -0,0 +1,125 @@
+import Mercury from '@webex/internal-plugin-mercury';
+
+
+import {LLM} from './constants';
+// eslint-disable-next-line no-unused-vars
+import {ILLMChannel} from './llm.types';
+
+export const config = {
+  llm: {
+    /**
+     * Milliseconds between pings sent up the socket
+     * @type {number}
+     */
+    pingInterval: process.env.MERCURY_PING_INTERVAL || 15000,
+    /**
+     * Milliseconds to wait for a pong before declaring the connection dead
+     * @type {number}
+     */
+    pongTimeout: process.env.MERCURY_PONG_TIMEOUT || 14000,
+    /**
+     * Maximum milliseconds between connection attempts
+     * @type {Number}
+     */
+    backoffTimeMax: process.env.MERCURY_BACKOFF_TIME_MAX || 32000,
+    /**
+     * Initial milliseconds between connection attempts
+     * @type {Number}
+     */
+    backoffTimeReset: process.env.MERCURY_BACKOFF_TIME_RESET || 1000,
+    /**
+     * Milliseconds to wait for a close frame before declaring the socket dead and
+     * discarding it
+     * @type {[type]}
+     */
+    forceCloseDelay: process.env.MERCURY_FORCE_CLOSE_DELAY || 2000,
+  },
+};
+
+/**
+ * LLMChannel to provide socket connections
+ */
+export default class LLMChannel extends (Mercury as any) implements ILLMChannel {
+  namespace = LLM;
+
+  /**
+     * If the LLM plugin has been registered and listening
+     * @instance
+     * @type {Boolean}
+     * @public
+     */
+  private registered:boolean = false;
+
+  public webex: any;
+
+  private webSocketUrl: string;
+
+  private binding: string;
+
+  private locusUrl: string;
+
+
+  /**
+   * Initializes the LLM Plugin
+   * @constructor
+   * @public
+   */
+  constructor(...args) {
+    // eslint-disable-next-line constructor-super
+    super(...args);
+
+
+    this.registered = false;
+  }
+
+  /**
+   * Register to the websocket
+   * @param {string} llmSocketUrl
+   * @returns {Promise<void>}
+   */
+  private register = (llmSocketUrl:string):Promise<void> => this.request({
+    method: 'POST',
+    url: llmSocketUrl,
+  }).then((res: { body: { webSocketUrl: string; binding: string; }; }) => {
+    this.webSocketUrl = res.body.webSocketUrl;
+    this.binding = res.body.binding;
+  });
+
+  /**
+   * Register and connect to the websocket
+   * @param {string} locusUrl
+   * @param {string} datachannelUrl
+   * @returns {Promise<void>}
+   */
+  public registerAndConnect = (locusUrl:string, datachannelUrl:string):Promise<void> => this.register(datachannelUrl).then(() => {
+    if(!locusUrl || !datachannelUrl) return undefined;
+    this.locusUrl = locusUrl;
+    this.connect(this.webSocketUrl).then(() => {
+      this.registered = true;
+    });
+  });
+
+  /**
+   * Tells if LLM socket is connected
+   * @returns {boolean} isRegistered
+   */
+  public isConnected = ():boolean => this.registered;
+
+  /**
+   * Tells if LLM socket is connected
+   * @returns {bool} isRegistered
+   */
+  public getBinding = ():string => this.binding;
+
+  /**
+   * Get Locus URL for the connection
+   * @returns {string} locus Url
+   */
+  public getLocusUrl = ():string => this.locusUrl;
+  /**
+   * Disconnects websocket connection
+   * @returns Promise<void>
+   */
+  public disconnectLLM = () => this.disconnect()
+}
+

package/src/llm.types.ts

@@ -0,0 +1,10 @@
+
+interface ILLMChannel{
+    registerAndConnect: (locusUrl:string, datachannelUrl:string) => Promise<void>;
+    isConnected: () => boolean;
+    getBinding: () => string;
+    getLocusUrl: () => string;
+    disconnectLLM: () => Promise<void>;
+}
+// eslint-disable-next-line import/prefer-default-export
+export {ILLMChannel};

package/test/unit/spec/llm.js

@@ -0,0 +1,96 @@
+import MockWebex from '@webex/test-helper-mock-webex';
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import Mercury from '@webex/internal-plugin-mercury';
+
+import LLMService from '@webex/internal-plugin-llm';
+
+
+describe('plugin-llm', () => {
+  const locusUrl = 'locusUrl';
+  const datachannelUrl = 'datachannelUrl';
+
+  describe('llm', () => {
+    let webex, llmService;
+
+    beforeEach(() => {
+      webex = new MockWebex({
+        children: {
+          mercury: Mercury,
+          llm: LLMService,
+        },
+      });
+
+      llmService = webex.internal.llm;
+      llmService.connect = sinon.stub().resolves(true);
+      llmService.disconnect = sinon.stub().resolves(true);
+      llmService.request = sinon.stub().resolves({
+        headers: {},
+        body: {
+          binding: 'binding',
+          webSocketUrl: 'url'
+        }
+      });
+    });
+
+
+    describe('#registerAndConnect', () => {
+      it('registers connection', async () => {
+        llmService.register = sinon.stub().resolves({
+          body: {
+            binding: 'binding',
+            webSocketUrl: 'url'
+          }
+        });
+        assert.equal(llmService.isConnected(), false);
+        await llmService.registerAndConnect(locusUrl, datachannelUrl);
+        assert.equal(llmService.isConnected(), true);
+      });
+
+      it('doesn\'t registers connection for invalid input', async () => {
+        llmService.register = sinon.stub().resolves({
+          body: {
+            binding: 'binding',
+            webSocketUrl: 'url'
+          }
+        });
+        await llmService.registerAndConnect();
+        assert.equal(llmService.isConnected(), false);
+      });
+    });
+
+    describe('#register', () => {
+      it('registers connection', async () => {
+        await llmService.register(datachannelUrl);
+
+
+        sinon.assert.calledOnceWithExactly(llmService.request, sinon.match({
+          method: 'POST',
+          url: `${datachannelUrl}`,
+        }));
+
+        assert.equal(llmService.getBinding(), 'binding');
+      });
+    });
+
+    describe('#getLocusUrl', () => {
+      it('gets LocusUrl', async () => {
+        llmService.register = sinon.stub().resolves({
+          body: {
+            binding: 'binding',
+            webSocketUrl: 'url'
+          }
+        });
+        await llmService.registerAndConnect(locusUrl, datachannelUrl);
+        assert.equal(llmService.getLocusUrl(), locusUrl);
+      });
+    });
+
+    describe('#disconnect', () => {
+      it('disconnects mercury', async () => {
+        await llmService.disconnect();
+        sinon.assert.calledOnce(llmService.disconnect);
+      });
+    });
+  });
+});