@webex/internal-plugin-llm 3.11.0 → 3.12.0-auth-prejoin-fetch.1

package/dist/llm.js

@@ -1,24 +1,35 @@
 "use strict";
 
 var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
+var _Array$from = require("@babel/runtime-corejs2/core-js/array/from");
+var _Symbol = require("@babel/runtime-corejs2/core-js/symbol");
+var _Symbol$iterator = require("@babel/runtime-corejs2/core-js/symbol/iterator");
+var _Array$isArray = require("@babel/runtime-corejs2/core-js/array/is-array");
 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 _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
+var _map = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/map"));
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/slicedToArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
 var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _defineProperty3 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
 var _internalPluginMercury = _interopRequireDefault(require("@webex/internal-plugin-mercury"));
 var _constants = require("./constants");
+var _llm = require("./llm.types");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof _Symbol && r[_Symbol$iterator] || r["@@iterator"]; if (!t) { if (_Array$isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? _Array$from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? _Reflect$construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); } /* eslint-disable consistent-return */
-// eslint-disable-next-line no-unused-vars
-
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); } /* eslint-disable consistent-return */ // eslint-disable-next-line no-unused-vars
 var config = exports.config = {
   llm: {
     /**
@@ -61,95 +72,565 @@ var LLMChannel = exports.default = /*#__PURE__*/function (_ref) {
       args[_key] = arguments[_key];
     }
     _this = _callSuper(this, LLMChannel, [].concat(args));
-    (0, _defineProperty2.default)(_this, "namespace", _constants.LLM);
+    (0, _defineProperty3.default)(_this, "namespace", _constants.LLM);
+    (0, _defineProperty3.default)(_this, "defaultSessionId", _constants.LLM_DEFAULT_SESSION);
     /**
-     * If the LLM plugin has been registered and listening
-     * @instance
-     * @type {Boolean}
-     * @public
+     * Map to store connection-specific data for multiple LLM connections
+     * Key: sessionId
+     * @private
+     * @type {Map<string, {webSocketUrl?: string; binding?: string; locusUrl?: string; datachannelUrl?: string}>}
      */
-    (0, _defineProperty2.default)(_this, "webSocketUrl", void 0);
-    (0, _defineProperty2.default)(_this, "binding", void 0);
-    (0, _defineProperty2.default)(_this, "locusUrl", void 0);
-    (0, _defineProperty2.default)(_this, "datachannelUrl", void 0);
+    (0, _defineProperty3.default)(_this, "connections", new _map.default());
+    // Session-keyed token cache is intentionally decoupled from connection state.
+    // Disconnecting a socket session must not implicitly wipe token cache.
+    (0, _defineProperty3.default)(_this, "datachannelTokens", (0, _defineProperty3.default)((0, _defineProperty3.default)({}, _llm.DataChannelTokenType.Default, undefined), _llm.DataChannelTokenType.PracticeSession, undefined));
     /**
      * Register to the websocket
      * @param {string} llmSocketUrl
+     * @param {string} datachannelToken
+     * @param {string} sessionId - Connection identifier
      * @returns {Promise<void>}
      */
-    (0, _defineProperty2.default)(_this, "register", function (llmSocketUrl) {
-      return _this.request({
-        method: 'POST',
-        url: llmSocketUrl,
-        body: {
-          deviceUrl: _this.webex.internal.device.url
-        }
-      }).then(function (res) {
-        _this.webSocketUrl = res.body.webSocketUrl;
-        _this.binding = res.body.binding;
-      }).catch(function (error) {
-        _this.logger.error("Error connecting to websocket: ".concat(error));
-        throw error;
-      });
-    });
+    (0, _defineProperty3.default)(_this, "register", /*#__PURE__*/function () {
+      var _ref2 = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee(llmSocketUrl, datachannelToken) {
+        var sessionId,
+          isDataChannelTokenEnabled,
+          _args = arguments;
+        return _regenerator.default.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              sessionId = _args.length > 2 && _args[2] !== undefined ? _args[2] : _constants.LLM_DEFAULT_SESSION;
+              _context.next = 1;
+              return _this.isDataChannelTokenEnabled();
+            case 1:
+              isDataChannelTokenEnabled = _context.sent;
+              return _context.abrupt("return", _this.request({
+                method: 'POST',
+                url: llmSocketUrl,
+                body: {
+                  deviceUrl: _this.webex.internal.device.url
+                },
+                headers: isDataChannelTokenEnabled && datachannelToken ? {
+                  'Data-Channel-Auth-Token': datachannelToken
+                } : {}
+              }).then(function (res) {
+                // Get or create connection data
+                var sessionData = _this.connections.get(sessionId) || {};
+                sessionData.webSocketUrl = res.body.webSocketUrl;
+                sessionData.binding = res.body.binding;
+                _this.connections.set(sessionId, sessionData);
+              }).catch(function (error) {
+                _this.logger.error("Error connecting to websocket for ".concat(sessionId, ": ").concat(error));
+                throw error;
+              }));
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      return function (_x, _x2) {
+        return _ref2.apply(this, arguments);
+      };
+    }());
     /**
      * Register and connect to the websocket
      * @param {string} locusUrl
      * @param {string} datachannelUrl
+     * @param {string} datachannelToken
+     * @param {string} sessionId - Connection identifier
      * @returns {Promise<void>}
      */
-    (0, _defineProperty2.default)(_this, "registerAndConnect", function (locusUrl, datachannelUrl) {
-      return _this.register(datachannelUrl).then(function () {
-        if (!locusUrl || !datachannelUrl) return undefined;
-        _this.locusUrl = locusUrl;
-        _this.datachannelUrl = datachannelUrl;
-        _this.connect(_this.webSocketUrl);
-      });
+    (0, _defineProperty3.default)(_this, "registerAndConnect", function (locusUrl, datachannelUrl, datachannelToken) {
+      var sessionId = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _constants.LLM_DEFAULT_SESSION;
+      var registerStart = performance.now();
+
+      // Pre-populate locusUrl and datachannelUrl before register() fires the
+      // HTTP POST, so that any token refresh triggered during registration can
+      // be routed via connections without falling back to a locusInfo URL scan.
+      if (locusUrl && datachannelUrl) {
+        var sessionData = _this.connections.get(sessionId) || {};
+        sessionData.locusUrl = locusUrl;
+        sessionData.datachannelUrl = datachannelUrl;
+        _this.connections.set(sessionId, sessionData);
+      }
+      return _this.register(datachannelUrl, datachannelToken, sessionId).then(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2() {
+        var clientLLMDatachannelResponseTime, sessionData, error, isDataChannelTokenEnabled, connectUrl, connectStart, clientLLMWebSocketConnectTime, _t;
+        return _regenerator.default.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (!(!locusUrl || !datachannelUrl)) {
+                _context2.next = 1;
+                break;
+              }
+              return _context2.abrupt("return", undefined);
+            case 1:
+              clientLLMDatachannelResponseTime = Math.round(performance.now() - registerStart); // locusUrl and datachannelUrl were pre-populated before register(); here
+              // we only need to read the existing session data to get webSocketUrl/binding
+              // that register() filled in.
+              sessionData = _this.connections.get(sessionId) || {};
+              if (sessionData.webSocketUrl) {
+                _context2.next = 2;
+                break;
+              }
+              // register() succeeded but the response carried no websocket URL. Attach the measured
+              // datachannel time so callers don't misreport a registration that completed as time 0.
+              error = new Error("LLM registration for ".concat(sessionId, " returned no websocket URL"));
+              error.timing = {
+                clientLLMDatachannelResponseTime: clientLLMDatachannelResponseTime
+              };
+              throw error;
+            case 2:
+              _context2.next = 3;
+              return _this.isDataChannelTokenEnabled();
+            case 3:
+              isDataChannelTokenEnabled = _context2.sent;
+              connectUrl = isDataChannelTokenEnabled ? LLMChannel.buildUrlWithAwareSubchannels(sessionData.webSocketUrl, _constants.AWARE_DATA_CHANNEL) : sessionData.webSocketUrl;
+              connectStart = performance.now();
+              _context2.prev = 4;
+              _context2.next = 5;
+              return _this.connect(connectUrl, sessionId);
+            case 5:
+              _context2.next = 7;
+              break;
+            case 6:
+              _context2.prev = 6;
+              _t = _context2["catch"](4);
+              // register() succeeded; only connect() failed. Attach the measured datachannel time so
+              // callers don't misreport a websocket failure as a registration that never completed.
+              // @ts-ignore
+              _t.timing = {
+                clientLLMDatachannelResponseTime: clientLLMDatachannelResponseTime
+              };
+              throw _t;
+            case 7:
+              clientLLMWebSocketConnectTime = Math.round(performance.now() - connectStart);
+              return _context2.abrupt("return", {
+                clientLLMDatachannelResponseTime: clientLLMDatachannelResponseTime,
+                clientLLMWebSocketConnectTime: clientLLMWebSocketConnectTime
+              });
+            case 8:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, null, [[4, 6]]);
+      })));
     });
     /**
      * Tells if LLM socket is connected
+     * @param {string} sessionId - Connection identifier
      * @returns {boolean} connected
      */
-    (0, _defineProperty2.default)(_this, "isConnected", function () {
-      return _this.connected;
+    (0, _defineProperty3.default)(_this, "isConnected", function () {
+      var sessionId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _constants.LLM_DEFAULT_SESSION;
+      var socket = _this.getSocket(sessionId);
+      return socket ? socket.connected : false;
     });
     /**
      * Tells if LLM socket is binding
+     * @param {string} sessionId - Connection identifier
      * @returns {string} binding
      */
-    (0, _defineProperty2.default)(_this, "getBinding", function () {
-      return _this.binding;
+    (0, _defineProperty3.default)(_this, "getBinding", function () {
+      var sessionId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _constants.LLM_DEFAULT_SESSION;
+      var sessionData = _this.connections.get(sessionId);
+      return sessionData === null || sessionData === void 0 ? void 0 : sessionData.binding;
     });
     /**
      * Get Locus URL for the connection
+     * @param {string} sessionId - Connection identifier
      * @returns {string} locus Url
      */
-    (0, _defineProperty2.default)(_this, "getLocusUrl", function () {
-      return _this.locusUrl;
+    (0, _defineProperty3.default)(_this, "getLocusUrl", function () {
+      var sessionId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _constants.LLM_DEFAULT_SESSION;
+      var sessionData = _this.connections.get(sessionId);
+      return sessionData === null || sessionData === void 0 ? void 0 : sessionData.locusUrl;
     });
     /**
      * Get data channel URL for the connection
+     * @param {string} sessionId - Connection identifier
      * @returns {string} data channel Url
      */
-    (0, _defineProperty2.default)(_this, "getDatachannelUrl", function () {
-      return _this.datachannelUrl;
+    (0, _defineProperty3.default)(_this, "getDatachannelUrl", function () {
+      var sessionId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _constants.LLM_DEFAULT_SESSION;
+      var sessionData = _this.connections.get(sessionId);
+      return sessionData === null || sessionData === void 0 ? void 0 : sessionData.datachannelUrl;
+    });
+    /**
+     * Get WebSocket URL for the connection
+     * @param {string} sessionId - Connection identifier
+     * @returns {string | undefined} WebSocket URL
+     */
+    (0, _defineProperty3.default)(_this, "getWebSocketUrl", function () {
+      var sessionId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _constants.LLM_DEFAULT_SESSION;
+      var sessionData = _this.connections.get(sessionId);
+      return sessionData === null || sessionData === void 0 ? void 0 : sessionData.webSocketUrl;
+    });
+    /**
+     * Set the owner meeting ID for a given LLM session. Used by the meetings
+     * plugin to tag which Meeting instance currently owns the (default) LLM
+     * connection so that other Meeting instances can avoid disconnecting or
+     * re-initializing a connection they do not own.
+     *
+     * Does NOT create a connections entry if one does not already exist — this
+     * method is a no-op when there is no active session data. Callers should
+     * invoke it after a successful `registerAndConnect` or during an explicit
+     * ownership handoff.
+     *
+     * @param {string | undefined} ownerMeetingId - Meeting ID (or undefined to clear)
+     * @param {string} sessionId - Connection identifier (defaults to default session)
+     * @returns {void}
+     */
+    (0, _defineProperty3.default)(_this, "setOwnerMeetingId", function (ownerMeetingId) {
+      var sessionId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _constants.LLM_DEFAULT_SESSION;
+      var sessionData = _this.connections.get(sessionId);
+      if (!sessionData) {
+        return;
+      }
+      sessionData.ownerMeetingId = ownerMeetingId;
+      _this.connections.set(sessionId, sessionData);
+    });
+    /**
+     * Get the owner meeting ID currently associated with an LLM session.
+     * Returns undefined when no owner has been assigned (e.g. before the
+     * first successful `registerAndConnect`, or after `disconnectLLM`).
+     *
+     * @param {string} sessionId - Connection identifier (defaults to default session)
+     * @returns {string | undefined} ownerMeetingId
+     */
+    (0, _defineProperty3.default)(_this, "getOwnerMeetingId", function () {
+      var sessionId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _constants.LLM_DEFAULT_SESSION;
+      var sessionData = _this.connections.get(sessionId);
+      return sessionData === null || sessionData === void 0 ? void 0 : sessionData.ownerMeetingId;
+    });
+    /**
+     * Resolve ownership information for an LLM session.
+     *
+     * Rules:
+     * - no current owner => caller may proceed
+     * - caller has no identity to assert => treat as owner
+     * - otherwise caller must match current owner
+     *
+     * @param {string | undefined} ownerMeetingId - Candidate owner to evaluate
+     * @param {string} sessionId - Connection identifier (defaults to default session)
+     * @returns {{currentOwner: (string|undefined), isOwner: boolean}}
+     */
+    (0, _defineProperty3.default)(_this, "resolveSessionOwnership", function (ownerMeetingId) {
+      var sessionId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _constants.LLM_DEFAULT_SESSION;
+      var currentOwner = _this.getOwnerMeetingId(sessionId);
+      var isOwner = !currentOwner || !ownerMeetingId || currentOwner === ownerMeetingId;
+      return {
+        currentOwner: currentOwner,
+        isOwner: isOwner
+      };
+    });
+    /**
+     * Get data channel token for the connection
+     * @param {DataChannelTokenType|string} tokenKey
+     * @param {string | undefined} ownerMeetingId - Meeting id asserting read ownership
+     * @returns {string | undefined} data channel token
+     */
+    (0, _defineProperty3.default)(_this, "getDatachannelToken", function (tokenKey, ownerMeetingId) {
+      var resolvedTokenKey = tokenKey !== null && tokenKey !== void 0 ? tokenKey : _llm.DataChannelTokenType.Default;
+      var _this$resolveSessionO = _this.resolveSessionOwnership(ownerMeetingId, resolvedTokenKey),
+        currentOwner = _this$resolveSessionO.currentOwner,
+        isOwner = _this$resolveSessionO.isOwner;
+      if (!isOwner) {
+        _this.logger.info("llm#getDatachannelToken --> skip read for session ".concat(resolvedTokenKey, "; owned by ").concat(currentOwner, ", candidate ").concat(ownerMeetingId));
+        return undefined;
+      }
+      return _this.datachannelTokens[resolvedTokenKey];
+    });
+    /**
+     * Set data channel token for the connection
+     * @param {string} datachannelToken - data channel token
+     * @param {DataChannelTokenType|string} [tokenKey]
+     * @param {string | undefined} ownerMeetingId - Meeting id asserting write ownership
+     * @returns {void}
+     */
+    (0, _defineProperty3.default)(_this, "setDatachannelToken", function (datachannelToken, tokenKey, ownerMeetingId) {
+      var resolvedTokenKey = tokenKey !== null && tokenKey !== void 0 ? tokenKey : _llm.DataChannelTokenType.Default;
+      var _this$resolveSessionO2 = _this.resolveSessionOwnership(ownerMeetingId, resolvedTokenKey),
+        currentOwner = _this$resolveSessionO2.currentOwner,
+        isOwner = _this$resolveSessionO2.isOwner;
+      if (!isOwner) {
+        _this.logger.info("llm#setDatachannelToken --> skip write for session ".concat(resolvedTokenKey, "; owned by ").concat(currentOwner, ", candidate ").concat(ownerMeetingId));
+        return;
+      }
+      _this.datachannelTokens[resolvedTokenKey] = datachannelToken;
+    });
+    /**
+     * Clears a single session's data channel token.
+     * @param {DataChannelTokenType|string} tokenKey
+     * @param {string} ownerMeetingId - Meeting id asserting delete ownership
+     * @returns {void}
+     */
+    (0, _defineProperty3.default)(_this, "clearDatachannelToken", function (tokenKey, ownerMeetingId) {
+      var resolvedTokenKey = tokenKey;
+      var _this$resolveSessionO3 = _this.resolveSessionOwnership(ownerMeetingId, resolvedTokenKey),
+        currentOwner = _this$resolveSessionO3.currentOwner,
+        isOwner = _this$resolveSessionO3.isOwner;
+      if (!isOwner) {
+        _this.logger.info("llm#clearDatachannelToken --> skip clear for session ".concat(resolvedTokenKey, "; owned by ").concat(currentOwner, ", candidate ").concat(ownerMeetingId));
+        return;
+      }
+      _this.datachannelTokens[resolvedTokenKey] = undefined;
+      delete _this.datachannelTokens[resolvedTokenKey];
     });
     /**
      * Disconnects websocket connection
      * @param {{code: number, reason: string}} options - The disconnect option object with code and reason
+     * @param {string} sessionId - Connection identifier
+     * @param {string} ownerMeetingId - Meeting id asserting disconnect ownership
+     * @returns {Promise<boolean>} True when disconnect was performed, false when skipped
+     */
+    (0, _defineProperty3.default)(_this, "disconnectLLM", function (options, sessionId, ownerMeetingId) {
+      var resolvedSessionId = sessionId !== null && sessionId !== void 0 ? sessionId : _constants.LLM_DEFAULT_SESSION;
+
+      // Backward-compat path: historically callers could omit ownerMeetingId
+      // (and sometimes sessionId). Reuse current owner when available so legacy
+      // calls remain best-effort without throwing at teardown time.
+      var resolvedOwnerMeetingId = ownerMeetingId || _this.getOwnerMeetingId(resolvedSessionId);
+      if (!ownerMeetingId) {
+        _this.logger.warn("llm#disconnectLLM --> ownerMeetingId is omitted for session ".concat(resolvedSessionId, "; using legacy compatibility path"));
+      }
+      var _this$resolveSessionO4 = _this.resolveSessionOwnership(resolvedOwnerMeetingId, resolvedSessionId),
+        currentOwner = _this$resolveSessionO4.currentOwner,
+        isOwner = _this$resolveSessionO4.isOwner;
+      if (!isOwner) {
+        _this.logger.info("llm#disconnectLLM --> skip disconnect for session ".concat(resolvedSessionId, "; owned by ").concat(currentOwner, ", candidate ").concat(resolvedOwnerMeetingId));
+        return _promise.default.resolve(false);
+      }
+      return _this.disconnect(options, resolvedSessionId).then(function () {
+        // Clear owner tag before cleanup to ensure it's not lingering
+        // if another meeting claimed it during disconnect
+        _this.setOwnerMeetingId(undefined, resolvedSessionId);
+
+        // Clean up sessions data
+        _this.connections.delete(resolvedSessionId);
+        return true;
+      });
+    });
+    /**
+     * Disconnects all LLM websocket connections
+     * @param {{code: number, reason: string}} options - The disconnect option object with code and reason
      * @returns {Promise<void>}
      */
-    (0, _defineProperty2.default)(_this, "disconnectLLM", function (options) {
-      return _this.disconnect(options).then(function () {
-        _this.locusUrl = undefined;
-        _this.datachannelUrl = undefined;
-        _this.binding = undefined;
-        _this.webSocketUrl = undefined;
+    (0, _defineProperty3.default)(_this, "disconnectAllLLM", function (options) {
+      return _this.disconnectAll(options).then(function () {
+        // Clean up all connection data
+        _this.connections.clear();
       });
     });
+    /**
+     * Get all active LLM connections
+     * @returns {Map} Map of sessionId to session data
+     */
+    (0, _defineProperty3.default)(_this, "getAllConnections", function () {
+      return new _map.default(_this.connections);
+    });
     return _this;
   }
   (0, _inherits2.default)(LLMChannel, _ref);
-  return (0, _createClass2.default)(LLMChannel);
+  return (0, _createClass2.default)(LLMChannel, [{
+    key: "setRefreshHandler",
+    value:
+    /**
+     * Set the handler used to refresh the DataChannel token
+     *
+     * @param {function} handler - Function that returns a refreshed token
+     * @param {string} [sessionId] - Connection identifier
+     * @param {string | undefined} ownerMeetingId - Meeting id asserting refresh-handler ownership
+     * @returns {void}
+     */
+    function setRefreshHandler(handler, sessionId, ownerMeetingId) {
+      var resolvedSessionId = sessionId !== null && sessionId !== void 0 ? sessionId : _constants.LLM_DEFAULT_SESSION;
+      var _this$resolveSessionO5 = this.resolveSessionOwnership(ownerMeetingId, resolvedSessionId),
+        currentOwner = _this$resolveSessionO5.currentOwner,
+        isOwner = _this$resolveSessionO5.isOwner;
+      if (!isOwner) {
+        this.logger.info("llm#setRefreshHandler --> skip write for session ".concat(resolvedSessionId, "; owned by ").concat(currentOwner, ", candidate ").concat(ownerMeetingId));
+        return;
+      }
+      var sessionData = this.connections.get(resolvedSessionId);
+      if (sessionData) {
+        sessionData.refreshHandler = handler;
+        if (ownerMeetingId) {
+          sessionData.ownerMeetingId = ownerMeetingId;
+        }
+        return;
+      }
+
+      // Intentionally allow a pre-connection session shape here.
+      // Some flows inject refreshHandler before register/connect so token refresh
+      // is already wired when the socket lifecycle starts. register()/
+      // registerAndConnect() will later fill webSocketUrl/binding/locusUrl/
+      // datachannelUrl into this same session entry.
+      this.connections.set(resolvedSessionId, {
+        refreshHandler: handler,
+        ownerMeetingId: ownerMeetingId
+      });
+    }
+
+    /**
+     * Refresh the data channel token using the injected handler.
+     * Logs a descriptive error if the handler is missing or fails.
+     * @param {string} sessionId - Connection identifier (defaults to default session)
+     * @returns {Promise<string>} The refreshed token.
+     */
+  }, {
+    key: "refreshDataChannelToken",
+    value: (function () {
+      var _refreshDataChannelToken = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
+        var _this$connections$get;
+        var sessionId,
+          refreshHandler,
+          res,
+          _args3 = arguments,
+          _t2;
+        return _regenerator.default.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              sessionId = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : _constants.LLM_DEFAULT_SESSION;
+              refreshHandler = (_this$connections$get = this.connections.get(sessionId)) === null || _this$connections$get === void 0 ? void 0 : _this$connections$get.refreshHandler;
+              if (refreshHandler) {
+                _context3.next = 1;
+                break;
+              }
+              this.logger.warn("llm#refreshDataChannelToken --> LLM refreshHandler is not set for session ".concat(sessionId, ", skipping token refresh"));
+              return _context3.abrupt("return", null);
+            case 1:
+              _context3.prev = 1;
+              _context3.next = 2;
+              return refreshHandler();
+            case 2:
+              res = _context3.sent;
+              return _context3.abrupt("return", res);
+            case 3:
+              _context3.prev = 3;
+              _t2 = _context3["catch"](1);
+              this.logger.warn("llm#refreshDataChannelToken --> DataChannel token refresh failed (likely locus changed or participant left): ".concat((_t2 === null || _t2 === void 0 ? void 0 : _t2.message) || _t2));
+              return _context3.abrupt("return", null);
+            case 4:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[1, 3]]);
+      }));
+      function refreshDataChannelToken() {
+        return _refreshDataChannelToken.apply(this, arguments);
+      }
+      return refreshDataChannelToken;
+    }())
+  }, {
+    key: "getLocusUrlByDatachannelUrl",
+    value:
+    /**
+     * Look up the locusUrl associated with a datachannel request URL.
+     * Iterates all active LLM sessions and returns the locusUrl of the
+     * session whose stored datachannelUrl is a prefix of the given request URL.
+     *
+     * @param {string} requestUrl - The in-flight request URL to match
+     * @returns {string | undefined} The matching locusUrl, or undefined if not found
+     */
+    function getLocusUrlByDatachannelUrl(requestUrl) {
+      var _iterator = _createForOfIteratorHelper(this.connections),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = (0, _slicedToArray2.default)(_step.value, 2),
+            connection = _step$value[1];
+          if (connection.datachannelUrl && LLMChannel.matchesDatachannelRequestUrl(requestUrl, connection.datachannelUrl)) {
+            return connection.locusUrl;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return undefined;
+    }
+
+    /**
+     * Look up the sessionId associated with a datachannel request URL.
+     * Iterates all active LLM sessions and returns the sessionId whose
+     * stored datachannelUrl is a prefix of the given request URL.
+     *
+     * @param {string} requestUrl - The in-flight request URL to match
+     * @returns {string | undefined} The matching sessionId, or undefined if not found
+     */
+  }, {
+    key: "getSessionIdByDatachannelUrl",
+    value: function getSessionIdByDatachannelUrl(requestUrl) {
+      var _iterator2 = _createForOfIteratorHelper(this.connections),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = (0, _slicedToArray2.default)(_step2.value, 2),
+            sessionId = _step2$value[0],
+            connection = _step2$value[1];
+          if (connection.datachannelUrl && LLMChannel.matchesDatachannelRequestUrl(requestUrl, connection.datachannelUrl)) {
+            return sessionId;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return undefined;
+    }
+
+    /**
+     * Matches a request URL to a stored datachannel registration URL.
+     * Host can differ (e.g. rewritten by hostmap interceptor), so we first
+     * try full URL prefix and then fall back to pathname prefix.
+     * @param {string} requestUrl
+     * @param {string} registrationUrl
+     * @returns {boolean}
+     */
+  }, {
+    key: "isDataChannelTokenEnabled",
+    value:
+    /**
+     * Returns true if  data channel token is enabled, false otherwise
+     * @returns {Promise<boolean>} resolves with true if data channel token  is enabled
+     */
+    function isDataChannelTokenEnabled() {
+      // @ts-ignore
+      return this.webex.internal.feature.getFeature('developer', _constants.DATA_CHANNEL_WITH_JWT_TOKEN);
+    }
+
+    /**
+     * Builds a WebSocket URL with the `subscriptionAwareSubchannels` query parameter.
+     *
+     * @param {string} baseUrl - The original WebSocket URL.
+     * @param {string[]} subchannels - List of subchannels to declare as subscription-aware.
+     * @returns {string} The final URL with updated query parameters.
+     */
+  }], [{
+    key: "matchesDatachannelRequestUrl",
+    value: function matchesDatachannelRequestUrl(requestUrl, registrationUrl) {
+      if (!requestUrl || !registrationUrl) {
+        return false;
+      }
+      if (requestUrl.startsWith(registrationUrl)) {
+        return true;
+      }
+      try {
+        var request = new URL(requestUrl);
+        var registration = new URL(registrationUrl);
+        return request.pathname.startsWith(registration.pathname);
+      } catch (error) {
+        return false;
+      }
+    }
+  }]);
 }(_internalPluginMercury.default);
+(0, _defineProperty3.default)(LLMChannel, "buildUrlWithAwareSubchannels", function (baseUrl, subchannels) {
+  var urlObj = new URL(baseUrl);
+  urlObj.searchParams.set(_constants.SUBSCRIPTION_AWARE_SUBCHANNELS_PARAM, subchannels.join(','));
+  return urlObj.toString();
+});
 //# sourceMappingURL=llm.js.map