roboto-js 1.7.0 → 1.7.1

package/dist/rbt_api.js

@@ -0,0 +1,1951 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _axios = _interopRequireDefault(require("axios"));
+var _cryptoJs = _interopRequireDefault(require("crypto-js"));
+var _rbt_object = _interopRequireDefault(require("./rbt_object.js"));
+var _rbt_user = _interopRequireDefault(require("./rbt_user.js"));
+var _rbt_file = _interopRequireDefault(require("./rbt_file.js"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _idb = require("idb");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+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) { _defineProperty(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; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _regenerator() { /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag"; function i(r, n, o, i) { var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype); return _regeneratorDefine2(u, "_invoke", function (r, n, o) { var i, c, u, f = 0, p = o || [], y = !1, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d(t, r) { return i = t, c = 0, u = e, G.n = r, a; } }; function d(r, n) { for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { var o, i = p[t], d = G.p, l = i[2]; r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); } if (o || r > 1) return a; throw y = !0, n; } return function (o, p, l) { if (f > 1) throw TypeError("Generator is already running"); for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); try { if (f = 2, i) { if (c || (o = "next"), t = i[o]) { if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); if (!t.done) return t; u = t.value, c < 2 && (c = 0); } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); i = e; } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; } catch (t) { i = e, c = 1, u = t; } finally { f = 1; } } return { value: t, done: y }; }; }(r, o, i), !0), u; } var a = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} t = Object.getPrototypeOf; var c = [][n] ? t(t([][n]())) : (_regeneratorDefine2(t = {}, n, function () { return this; }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); function f(e) { return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine2(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine2(u), _regeneratorDefine2(u, o, "Generator"), _regeneratorDefine2(u, n, function () { return this; }), _regeneratorDefine2(u, "toString", function () { return "[object Generator]"; }), (_regenerator = function _regenerator() { return { w: i, m: f }; })(); }
+function _regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try { i({}, "", {}); } catch (e) { i = 0; } _regeneratorDefine2 = function _regeneratorDefine(e, r, n, t) { function o(r, n) { _regeneratorDefine2(e, r, function (e) { return this._invoke(r, n, e); }); } r ? i ? i(e, r, { value: n, enumerable: !t, configurable: !t, writable: !t }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); }, _regeneratorDefine2(e, r, n, t); }
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+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 _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var RbtApi = exports["default"] = /*#__PURE__*/function () {
+  function RbtApi(_ref) {
+    var baseUrl = _ref.baseUrl,
+      accesskey = _ref.accesskey,
+      _ref$authtoken = _ref.authtoken,
+      authtoken = _ref$authtoken === void 0 ? null : _ref$authtoken,
+      _ref$apikey = _ref.apikey,
+      apikey = _ref$apikey === void 0 ? null : _ref$apikey,
+      _ref$localStorageAdap = _ref.localStorageAdaptor,
+      localStorageAdaptor = _ref$localStorageAdap === void 0 ? null : _ref$localStorageAdap;
+    _classCallCheck(this, RbtApi);
+    this.websocketClient = null;
+
+    // Object cache for sharing instances across multiple load() calls
+    this._objectCache = new Map();
+
+    // Track pending requests to prevent duplicate loads
+    this._pendingLoads = new Map();
+
+    // Track what we've already logged to reduce console spam
+    this._loggedCacheEvents = new Set();
+    this.axios = _axios["default"].create({
+      baseURL: baseUrl,
+      headers: {
+        'accesskey': accesskey
+      }
+    });
+    this.axios.__rbtApiInstance = this;
+    if (localStorageAdaptor) {
+      // must implement getItem, setItem interface
+      this.localStorageAdaptor = localStorageAdaptor;
+    } else if (typeof localStorage != 'undefined') {
+      // browser based local storage
+      this.localStorageAdaptor = {
+        getItem: function getItem(key) {
+          return Promise.resolve(localStorage.getItem(key));
+        },
+        setItem: function setItem(key, value) {
+          return Promise.resolve(localStorage.setItem(key, value));
+        },
+        removeItem: function removeItem(key) {
+          return Promise.resolve(localStorage.removeItem(key));
+        }
+      };
+    }
+
+    // Synchronous browser hydration: set auth header and in-memory user immediately
+    if (typeof localStorage !== 'undefined') {
+      try {
+        var token = localStorage.getItem('authtoken');
+        if (token) {
+          this.authtoken = token;
+          this.axios.defaults.headers.common['authtoken'] = token;
+        }
+      } catch (_unused) {}
+      try {
+        var cachedUser = localStorage.getItem('rbtUser');
+        if (cachedUser) {
+          var parsed = JSON.parse(cachedUser);
+          if (parsed && parsed.id) {
+            this.currentUser = new _rbt_user["default"]({
+              id: parsed.id
+            }, this.axios);
+            this.currentUser.setData(parsed);
+          }
+        }
+      } catch (_unused2) {}
+    }
+    this.localDb = null;
+    this.iac_session = null;
+    this.appServiceHost = baseUrl;
+    this.requestCache = {};
+    this._loadCurrentUserPromise = null;
+    this._loadCurrentUserExtendedPromise = null;
+
+    // Use the storageAdaptor to get the authToken, if available
+    this.initAuthToken(authtoken);
+    this.initApiKey(apikey);
+  }
+  return _createClass(RbtApi, [{
+    key: "getWebSocketClient",
+    value: function getWebSocketClient() {
+      // Reuse existing WebSocket if it's OPEN or CONNECTING (to prevent race condition)
+      if (this.websocketClient && (this.websocketClient.readyState === WebSocket.OPEN || this.websocketClient.readyState === WebSocket.CONNECTING)) {
+        return this.websocketClient;
+      }
+      var baseUrl = this.axios.defaults.baseURL;
+      var wsProtocol = baseUrl.startsWith('https') ? 'wss://' : 'ws://';
+      var wsUrl = baseUrl.replace(/^https?:\/\//, wsProtocol);
+      console.log('[RbtApi] Creating new WebSocket connection to:', wsUrl + '/realtime');
+      this.websocketClient = new WebSocket("".concat(wsUrl, "/realtime"));
+      this._setupWebSocketHandlers(this.websocketClient);
+      return this.websocketClient;
+    }
+  }, {
+    key: "_setupWebSocketHandlers",
+    value: function _setupWebSocketHandlers(ws) {
+      var _this = this;
+      ws.onopen = function () {
+        console.log('[RbtApi] WebSocket connected.');
+        _this._wsReconnectAttempts = 0;
+        _this._wsConnected = true;
+
+        // Re-subscribe to all objects that were previously subscribed
+        if (_this._wsSubscriptions) {
+          var _iterator = _createForOfIteratorHelper(_this._wsSubscriptions),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var objectId = _step.value;
+              ws.send(JSON.stringify({
+                type: 'subscribe',
+                objectId: objectId
+              }));
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        }
+      };
+      ws.onclose = function (event) {
+        console.warn('[RbtApi] WebSocket closed:', event.code, event.reason);
+        _this._wsConnected = false;
+
+        // Attempt reconnection with exponential backoff
+        if (!_this._wsManualClose && _this._wsReconnectAttempts < 5) {
+          var delay = Math.min(1000 * Math.pow(2, _this._wsReconnectAttempts), 30000);
+          console.log("[RbtApi] Attempting reconnection in ".concat(delay, "ms (attempt ").concat(_this._wsReconnectAttempts + 1, "/5)"));
+          setTimeout(function () {
+            _this._wsReconnectAttempts++;
+            _this.websocketClient = null; // Clear the old connection
+            _this.getWebSocketClient(); // Create new connection
+          }, delay);
+        }
+      };
+      ws.onerror = function (err) {
+        console.error('[RbtApi] WebSocket error:', err);
+        _this._wsConnected = false;
+      };
+
+      // Handle ping/pong for keep-alive
+      ws.addEventListener('ping', function () {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.pong();
+        }
+      });
+
+      // Initialize connection tracking
+      this._wsReconnectAttempts = this._wsReconnectAttempts || 0;
+      this._wsConnected = false;
+      this._wsManualClose = false;
+      this._wsSubscriptions = this._wsSubscriptions || new Set();
+    }
+
+    // Method to track subscriptions for reconnection
+  }, {
+    key: "_trackSubscription",
+    value: function _trackSubscription(objectId) {
+      if (!this._wsSubscriptions) this._wsSubscriptions = new Set();
+      this._wsSubscriptions.add(objectId);
+    }
+  }, {
+    key: "_untrackSubscription",
+    value: function _untrackSubscription(objectId) {
+      if (this._wsSubscriptions) {
+        this._wsSubscriptions["delete"](objectId);
+      }
+    }
+
+    // Method to gracefully close WebSocket
+  }, {
+    key: "closeWebSocket",
+    value: function closeWebSocket() {
+      if (this.websocketClient) {
+        this._wsManualClose = true;
+        this.websocketClient.close();
+        this.websocketClient = null;
+      }
+    }
+  }, {
+    key: "initAuthToken",
+    value: function () {
+      var _initAuthToken = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(authtoken) {
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              if (!(!authtoken && this.localStorageAdaptor)) {
+                _context.n = 2;
+                break;
+              }
+              _context.n = 1;
+              return this.localStorageAdaptor.getItem('authtoken');
+            case 1:
+              authtoken = _context.v;
+            case 2:
+              if (authtoken) {
+                this.authtoken = authtoken;
+                this.axios.defaults.headers.common['authtoken'] = this.authtoken;
+              }
+            case 3:
+              return _context.a(2);
+          }
+        }, _callee, this);
+      }));
+      function initAuthToken(_x) {
+        return _initAuthToken.apply(this, arguments);
+      }
+      return initAuthToken;
+    }()
+  }, {
+    key: "initApiKey",
+    value: function () {
+      var _initApiKey = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(apikey) {
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              if (!(!apikey && this.localStorageAdaptor)) {
+                _context2.n = 2;
+                break;
+              }
+              _context2.n = 1;
+              return this.localStorageAdaptor.getItem('apikey');
+            case 1:
+              apikey = _context2.v;
+            case 2:
+              if (apikey) {
+                this.apikey = apikey;
+                this.axios.defaults.headers.common['apikey'] = this.apikey;
+              }
+            case 3:
+              return _context2.a(2);
+          }
+        }, _callee2, this);
+      }));
+      function initApiKey(_x2) {
+        return _initApiKey.apply(this, arguments);
+      }
+      return initApiKey;
+    }()
+  }, {
+    key: "initLocalDb",
+    value: function () {
+      var _initLocalDb = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              _context3.n = 1;
+              return (0, _idb.openDB)('RBTFileDatabase', 1, {
+                upgrade: function upgrade(db) {
+                  if (!db.objectStoreNames.contains('files')) {
+                    db.createObjectStore('files', {
+                      autoIncrement: true
+                    });
+                  }
+                }
+              });
+            case 1:
+              this.localDb = _context3.v;
+            case 2:
+              return _context3.a(2);
+          }
+        }, _callee3, this);
+      }));
+      function initLocalDb() {
+        return _initLocalDb.apply(this, arguments);
+      }
+      return initLocalDb;
+    }()
+  }, {
+    key: "setAppServiceHost",
+    value: function setAppServiceHost(host) {
+      this.appServiceHost = host;
+      this.axios.defaults.baseURL = host;
+    }
+  }, {
+    key: "setSiteEnv",
+    value: function setSiteEnv(siteEnv) {
+      this.siteEnv = siteEnv;
+    }
+  }, {
+    key: "getSiteEnv",
+    value: function getSiteEnv() {
+      var key = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      if (key) {
+        return this.siteEnv[key];
+      }
+      return this.siteEnv;
+    }
+  }, {
+    key: "registerTypedefs",
+    value: function () {
+      var _registerTypedefs = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(typedefs) {
+        var response, _t;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.p = _context4.n) {
+            case 0:
+              _context4.p = 0;
+              _context4.n = 1;
+              return this.axios.post('/api/doctree/registerTypedefs', [{
+                typedefs: typedefs
+              }]);
+            case 1:
+              response = _context4.v;
+              return _context4.a(2, response.data);
+            case 2:
+              _context4.p = 2;
+              _t = _context4.v;
+              this._handleError(_t);
+            case 3:
+              return _context4.a(2);
+          }
+        }, _callee4, this, [[0, 2]]);
+      }));
+      function registerTypedefs(_x3) {
+        return _registerTypedefs.apply(this, arguments);
+      }
+      return registerTypedefs;
+    }()
+    /**
+       * Logs in a user and stores the authToken.
+       *
+       * @param {Object} params - The login parameters.
+       * @param {string} params.email - The email of the user.
+       * @param {string} params.password - The password of the user.
+       * @param {string} params.code - The password of the user.
+       * @returns {Promise<Object>} - The response data from the API.
+       */
+  }, {
+    key: "login",
+    value: (function () {
+      var _login = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(params) {
+        var response, _this$iac_session, _t2;
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.p = _context5.n) {
+            case 0:
+              _context5.p = 0;
+              _context5.n = 1;
+              return this.axios.post('/user_service/loginUser', [{
+                email: params.email,
+                password: params.password ? _cryptoJs["default"].MD5(params.password).toString(_cryptoJs["default"].enc.Hex) : null,
+                // legacy hash password (md5)
+                passwd: params.password || null,
+                // current password
+                code: params.code || null // single-use signon code (password resets)
+              }]);
+            case 1:
+              response = _context5.v;
+              if (!(response.data.ok === false)) {
+                _context5.n = 2;
+                break;
+              }
+              return _context5.a(2, this._handleError(response));
+            case 2:
+              this.iac_session = response.data;
+              this.currentUser = this.iac_session ? new _rbt_user["default"](this.iac_session.user, this.axios) : null;
+              // update axios instance headers with authtoken
+              this.axios.defaults.headers.common['authtoken'] = response.data.authToken;
+              this.authtoken = response.data.authToken;
+              if (!this.localStorageAdaptor) {
+                _context5.n = 4;
+                break;
+              }
+              _context5.n = 3;
+              return this.localStorageAdaptor.setItem('authtoken', response.data.authToken);
+            case 3:
+              if (!((_this$iac_session = this.iac_session) !== null && _this$iac_session !== void 0 && _this$iac_session.user)) {
+                _context5.n = 4;
+                break;
+              }
+              _context5.n = 4;
+              return this.localStorageAdaptor.setItem('rbtUser', JSON.stringify(this.iac_session.user));
+            case 4:
+              return _context5.a(2, response.data);
+            case 5:
+              _context5.p = 5;
+              _t2 = _context5.v;
+              this._handleError(_t2);
+            case 6:
+              return _context5.a(2);
+          }
+        }, _callee5, this, [[0, 5]]);
+      }));
+      function login(_x4) {
+        return _login.apply(this, arguments);
+      }
+      return login;
+    }())
+  }, {
+    key: "loginWithOauth",
+    value: function () {
+      var _loginWithOauth = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(userData) {
+        var response, _t3;
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.p = _context6.n) {
+            case 0:
+              _context6.p = 0;
+              _context6.n = 1;
+              return this.post('/api/account/registerOrSigninOauth', userData);
+            case 1:
+              response = _context6.v;
+              if (!(response.ok === false)) {
+                _context6.n = 2;
+                break;
+              }
+              return _context6.a(2, this._handleError(response));
+            case 2:
+              this.iac_session = response;
+              this.currentUser = this.iac_session ? new _rbt_user["default"](this.iac_session.user, this.axios) : null;
+              // update axios instance headers with authtoken
+              this.axios.defaults.headers.common['authtoken'] = response.authToken;
+              this.authtoken = response.authToken;
+              if (!this.localStorageAdaptor) {
+                _context6.n = 3;
+                break;
+              }
+              _context6.n = 3;
+              return this.localStorageAdaptor.setItem('authtoken', response.authToken);
+            case 3:
+              return _context6.a(2, response);
+            case 4:
+              _context6.p = 4;
+              _t3 = _context6.v;
+              this._handleError(_t3);
+            case 5:
+              return _context6.a(2);
+          }
+        }, _callee6, this, [[0, 4]]);
+      }));
+      function loginWithOauth(_x5) {
+        return _loginWithOauth.apply(this, arguments);
+      }
+      return loginWithOauth;
+    }()
+  }, {
+    key: "logout",
+    value: function () {
+      var _logout = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7() {
+        var response, _t4;
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.p = _context7.n) {
+            case 0:
+              _context7.p = 0;
+              _context7.n = 1;
+              return this.axios.post('/user_service/logoutUser');
+            case 1:
+              response = _context7.v;
+              if (!(response.data.ok === false)) {
+                _context7.n = 2;
+                break;
+              }
+              return _context7.a(2, this._handleError(response));
+            case 2:
+              // Clear the iac_session and remove the auth token from axios headers
+              this.iac_session = null;
+              this.currentUser = null;
+              this.authtoken = null;
+              if (this.axios.defaults.headers.common['authtoken']) {
+                delete this.axios.defaults.headers.common['authtoken'];
+              }
+
+              // Clear localStorage if it's being used
+              if (!this.localStorageAdaptor) {
+                _context7.n = 3;
+                break;
+              }
+              _context7.n = 3;
+              return this.localStorageAdaptor.removeItem('authtoken');
+            case 3:
+              return _context7.a(2, response.data);
+            case 4:
+              _context7.p = 4;
+              _t4 = _context7.v;
+              this._handleError(_t4);
+            case 5:
+              return _context7.a(2);
+          }
+        }, _callee7, this, [[0, 4]]);
+      }));
+      function logout() {
+        return _logout.apply(this, arguments);
+      }
+      return logout;
+    }()
+  }, {
+    key: "getCurrentUser",
+    value: function getCurrentUser() {
+      if (this.currentUser) {
+        return this.currentUser;
+      }
+    }
+  }, {
+    key: "loadCurrentUser",
+    value: function () {
+      var _loadCurrentUser = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9() {
+        var _this2 = this;
+        var result, _t5;
+        return _regenerator().w(function (_context9) {
+          while (1) switch (_context9.p = _context9.n) {
+            case 0:
+              _context9.p = 0;
+              if (!this._loadCurrentUserPromise) {
+                _context9.n = 1;
+                break;
+              }
+              return _context9.a(2, this._loadCurrentUserPromise);
+            case 1:
+              if (!this.currentUser) {
+                _context9.n = 2;
+                break;
+              }
+              return _context9.a(2, this.currentUser);
+            case 2:
+              if (!this.apikey) {
+                _context9.n = 3;
+                break;
+              }
+              return _context9.a(2, null);
+            case 3:
+              if (!this.authtoken) {
+                _context9.n = 5;
+                break;
+              }
+              this._loadCurrentUserPromise = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8() {
+                var response, _response$user;
+                return _regenerator().w(function (_context8) {
+                  while (1) switch (_context8.n) {
+                    case 0:
+                      _context8.n = 1;
+                      return _this2.refreshAuthToken(_this2.authtoken);
+                    case 1:
+                      response = _context8.v;
+                      if (response) {
+                        _context8.n = 2;
+                        break;
+                      }
+                      return _context8.a(2, null);
+                    case 2:
+                      if (!(response !== null && response !== void 0 && response.user)) {
+                        _context8.n = 3;
+                        break;
+                      }
+                      _this2.currentUser = new _rbt_user["default"]({
+                        id: response === null || response === void 0 || (_response$user = response.user) === null || _response$user === void 0 ? void 0 : _response$user.id
+                      }, _this2.axios);
+                      _this2.currentUser.setData(response.user);
+                      if (!_this2.localStorageAdaptor) {
+                        _context8.n = 3;
+                        break;
+                      }
+                      _context8.n = 3;
+                      return _this2.localStorageAdaptor.setItem('rbtUser', JSON.stringify(response.user));
+                    case 3:
+                      return _context8.a(2, _this2.currentUser);
+                  }
+                }, _callee8);
+              }))();
+              _context9.n = 4;
+              return this._loadCurrentUserPromise;
+            case 4:
+              result = _context9.v;
+              this._loadCurrentUserPromise = null;
+              return _context9.a(2, result);
+            case 5:
+              this.currentUser = null;
+            case 6:
+              return _context9.a(2, null);
+            case 7:
+              _context9.p = 7;
+              _t5 = _context9.v;
+              return _context9.a(2, this._handleError(_t5));
+          }
+        }, _callee9, this, [[0, 7]]);
+      }));
+      function loadCurrentUser() {
+        return _loadCurrentUser.apply(this, arguments);
+      }
+      return loadCurrentUser;
+    }()
+  }, {
+    key: "confirmUserEmail",
+    value: function () {
+      var _confirmUserEmail = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee0(confirmCode) {
+        var params, response, _t6;
+        return _regenerator().w(function (_context0) {
+          while (1) switch (_context0.p = _context0.n) {
+            case 0:
+              params = {
+                emailConfirmCode: confirmCode
+              };
+              _context0.p = 1;
+              _context0.n = 2;
+              return this.axios.post('/user_service/confirmUserEmail', [params]);
+            case 2:
+              response = _context0.v;
+              if (!(response.data.ok === false)) {
+                _context0.n = 3;
+                break;
+              }
+              return _context0.a(2, this._handleError(response));
+            case 3:
+              return _context0.a(2, response.data);
+            case 4:
+              _context0.p = 4;
+              _t6 = _context0.v;
+              return _context0.a(2, this._handleError(_t6));
+          }
+        }, _callee0, this, [[1, 4]]);
+      }));
+      function confirmUserEmail(_x6) {
+        return _confirmUserEmail.apply(this, arguments);
+      }
+      return confirmUserEmail;
+    }()
+  }, {
+    key: "loadCurrentUserExtended",
+    value: function () {
+      var _loadCurrentUserExtended = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee10() {
+        var _this3 = this;
+        return _regenerator().w(function (_context10) {
+          while (1) switch (_context10.p = _context10.n) {
+            case 0:
+              if (!this._loadCurrentUserExtendedPromise) {
+                _context10.n = 1;
+                break;
+              }
+              return _context10.a(2, this._loadCurrentUserExtendedPromise);
+            case 1:
+              this._loadCurrentUserExtendedPromise = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee1() {
+                var currentUser;
+                return _regenerator().w(function (_context1) {
+                  while (1) switch (_context1.n) {
+                    case 0:
+                      _context1.n = 1;
+                      return _this3.loadCurrentUser();
+                    case 1:
+                      currentUser = _context1.v;
+                      if (!currentUser) {
+                        _context1.n = 2;
+                        break;
+                      }
+                      return _context1.a(2, _this3.loadUser(currentUser.id));
+                    case 2:
+                      return _context1.a(2, null);
+                    case 3:
+                      return _context1.a(2);
+                  }
+                }, _callee1);
+              }))();
+              _context10.p = 2;
+              _context10.n = 3;
+              return this._loadCurrentUserExtendedPromise;
+            case 3:
+              return _context10.a(2, _context10.v);
+            case 4:
+              _context10.p = 4;
+              this._loadCurrentUserExtendedPromise = null;
+              return _context10.f(4);
+            case 5:
+              return _context10.a(2);
+          }
+        }, _callee10, this, [[2,, 4, 5]]);
+      }));
+      function loadCurrentUserExtended() {
+        return _loadCurrentUserExtended.apply(this, arguments);
+      }
+      return loadCurrentUserExtended;
+    }()
+  }, {
+    key: "loadUser",
+    value: function () {
+      var _loadUser = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee12(userId) {
+        var _this4 = this;
+        var params, cacheKey, now, existing, p, _t7;
+        return _regenerator().w(function (_context12) {
+          while (1) switch (_context12.p = _context12.n) {
+            case 0:
+              params = {
+                id: userId
+              };
+              cacheKey = "loadUser:".concat(userId);
+              now = Date.now();
+              existing = this.requestCache[cacheKey];
+              if (!(existing && now - existing.time < 10000)) {
+                _context12.n = 1;
+                break;
+              }
+              return _context12.a(2, existing.val);
+            case 1:
+              _context12.p = 1;
+              p = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee11() {
+                var _response$data;
+                var response, userData, User;
+                return _regenerator().w(function (_context11) {
+                  while (1) switch (_context11.n) {
+                    case 0:
+                      _context11.n = 1;
+                      return _this4.axios.post('/user_service/loadUser', [params]);
+                    case 1:
+                      response = _context11.v;
+                      userData = response === null || response === void 0 || (_response$data = response.data) === null || _response$data === void 0 ? void 0 : _response$data.user;
+                      User = new _rbt_user["default"]({
+                        id: userData.id
+                      }, _this4.axios);
+                      User.setData(userData);
+                      return _context11.a(2, User);
+                  }
+                }, _callee11);
+              }))();
+              this.requestCache[cacheKey] = {
+                val: p,
+                time: now
+              };
+              _context12.n = 2;
+              return p;
+            case 2:
+              return _context12.a(2, _context12.v);
+            case 3:
+              _context12.p = 3;
+              _t7 = _context12.v;
+              return _context12.a(2, this._handleError(_t7));
+          }
+        }, _callee12, this, [[1, 3]]);
+      }));
+      function loadUser(_x7) {
+        return _loadUser.apply(this, arguments);
+      }
+      return loadUser;
+    }()
+  }, {
+    key: "refreshAuthToken",
+    value: function () {
+      var _refreshAuthToken = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee13(authtoken) {
+        var promise, response, _t8;
+        return _regenerator().w(function (_context13) {
+          while (1) switch (_context13.p = _context13.n) {
+            case 0:
+              if (this.appServiceHost) {
+                _context13.n = 1;
+                break;
+              }
+              console.warn('RBTTOK not initialized');
+              return _context13.a(2, false);
+            case 1:
+              if (!this.requestCache[authtoken]) {
+                _context13.n = 2;
+                break;
+              }
+              return _context13.a(2, this.requestCache[authtoken]);
+            case 2:
+              _context13.p = 2;
+              //console.log('RBTTOK Req', authtoken);
+              // Create a new promise for the token refresh and store it in the cache
+              promise = this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+              this.requestCache[authtoken] = promise;
+
+              // Await the promise to get the response
+              _context13.n = 3;
+              return promise;
+            case 3:
+              response = _context13.v;
+              //console.log('RBTTOK Response ',response);
+              // Once the promise resolves, delete it from the cache to allow future refreshes
+              delete this.requestCache[authtoken];
+
+              // Return the response data
+              return _context13.a(2, response.data);
+            case 4:
+              _context13.p = 4;
+              _t8 = _context13.v;
+              // On error, remove the cached promise to allow retries
+              delete this.requestCache[authtoken];
+              this._handleError(_t8);
+            case 5:
+              return _context13.a(2);
+          }
+        }, _callee13, this, [[2, 4]]);
+      }));
+      function refreshAuthToken(_x8) {
+        return _refreshAuthToken.apply(this, arguments);
+      }
+      return refreshAuthToken;
+    }() //  async refreshAuthToken(authtoken){
+    //
+    //    if(!this.appServiceHost){
+    //      console.warn('appServiceHost not initialized');
+    //      return false;
+    //    }
+    //
+    //    try {
+    //
+    //      const response = await this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+    //      return response.data;
+    //
+    //    } catch (e) {
+    //
+    //      this._handleError(e);
+    //    }
+    //  }
+    /**
+     * Registers a new user.
+     *
+     * @param {Object} dataHash - The data for the new user.
+     * @returns {Promise<RbtObject>} - The newly created user as an RbtObject.
+     *
+     */
+  }, {
+    key: "registerUser",
+    value: function () {
+      var _registerUser = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee14() {
+        var dataHash,
+          response,
+          record,
+          _args14 = arguments,
+          _t9;
+        return _regenerator().w(function (_context14) {
+          while (1) switch (_context14.p = _context14.n) {
+            case 0:
+              dataHash = _args14.length > 0 && _args14[0] !== undefined ? _args14[0] : {};
+              _context14.p = 1;
+              _context14.n = 2;
+              return this.axios.post('/user_service/registerUser', [dataHash]);
+            case 2:
+              response = _context14.v;
+              record = response.data;
+              return _context14.a(2, new _rbt_user["default"](record, this.axios));
+            case 3:
+              _context14.p = 3;
+              _t9 = _context14.v;
+              return _context14.a(2, this._handleError(_t9));
+          }
+        }, _callee14, this, [[1, 3]]);
+      }));
+      function registerUser() {
+        return _registerUser.apply(this, arguments);
+      }
+      return registerUser;
+    }()
+    /**
+     * Creates a new file in the system.
+     *
+     * @param {Object} dataHash - The data for the new file.
+     * @returns {Promise<RbtFile>} - The newly created file as an RbtFile.
+     * 
+     */
+  }, {
+    key: "createFile",
+    value: (function () {
+      var _createFile = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee15(dataHash) {
+        var response, record, _t0;
+        return _regenerator().w(function (_context15) {
+          while (1) switch (_context15.p = _context15.n) {
+            case 0:
+              _context15.p = 0;
+              _context15.n = 1;
+              return this.axios.post('/object_service/createObject', ['<@filekit.file>', dataHash]);
+            case 1:
+              response = _context15.v;
+              record = response.data;
+              if (dataHash) {
+                record.data = dataHash;
+              }
+              return _context15.a(2, new _rbt_file["default"](record, this.axios, this.localDb));
+            case 2:
+              _context15.p = 2;
+              _t0 = _context15.v;
+              return _context15.a(2, this._handleError(_t0));
+          }
+        }, _callee15, this, [[0, 2]]);
+      }));
+      function createFile(_x9) {
+        return _createFile.apply(this, arguments);
+      }
+      return createFile;
+    }())
+  }, {
+    key: "loadFile",
+    value: function () {
+      var _loadFile = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee16(id) {
+        var response, record, _t1;
+        return _regenerator().w(function (_context16) {
+          while (1) switch (_context16.p = _context16.n) {
+            case 0:
+              _context16.p = 0;
+              _context16.n = 1;
+              return this.load('<@filekit.file>', id);
+            case 1:
+              response = _context16.v;
+              if (response) {
+                _context16.n = 2;
+                break;
+              }
+              return _context16.a(2, null);
+            case 2:
+              record = response.toRecord();
+              return _context16.a(2, new _rbt_file["default"](record, this.axios, this.localDb));
+            case 3:
+              _context16.p = 3;
+              _t1 = _context16.v;
+              return _context16.a(2, this._handleError(_t1));
+          }
+        }, _callee16, this, [[0, 3]]);
+      }));
+      function loadFile(_x0) {
+        return _loadFile.apply(this, arguments);
+      }
+      return loadFile;
+    }()
+  }, {
+    key: "loadFiles",
+    value: function () {
+      var _loadFiles = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee17(ids) {
+        var _this5 = this;
+        var responses, _t10;
+        return _regenerator().w(function (_context17) {
+          while (1) switch (_context17.p = _context17.n) {
+            case 0:
+              _context17.p = 0;
+              _context17.n = 1;
+              return this.load('<@filekit.file>', ids);
+            case 1:
+              responses = _context17.v;
+              if (!(!responses || !Array.isArray(responses))) {
+                _context17.n = 2;
+                break;
+              }
+              return _context17.a(2, []);
+            case 2:
+              return _context17.a(2, responses.map(function (response) {
+                var record = response.toRecord();
+                return new _rbt_file["default"](record, _this5.axios, _this5.localDb);
+              }));
+            case 3:
+              _context17.p = 3;
+              _t10 = _context17.v;
+              this._handleError(_t10); // Handle errors (log or process as needed)
+              return _context17.a(2, []);
+          }
+        }, _callee17, this, [[0, 3]]);
+      }));
+      function loadFiles(_x1) {
+        return _loadFiles.apply(this, arguments);
+      }
+      return loadFiles;
+    }()
+    /**
+     * Creates a new object of the given type.
+     *
+     * @param {string} type - The type of object to create.
+     * @param {Object} dataHash - The data for the new object.
+     * @param {Object} options - Additional options including enableRealtime.
+     * @returns {Promise<RbtObject>} - The newly created object as an RbtObject.
+     */
+  }, {
+    key: "create",
+    value: (function () {
+      var _create = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee18(type) {
+        var dataHash,
+          options,
+          response,
+          record,
+          _args18 = arguments,
+          _t11;
+        return _regenerator().w(function (_context18) {
+          while (1) switch (_context18.p = _context18.n) {
+            case 0:
+              dataHash = _args18.length > 1 && _args18[1] !== undefined ? _args18[1] : {};
+              options = _args18.length > 2 && _args18[2] !== undefined ? _args18[2] : {};
+              _context18.p = 1;
+              _context18.n = 2;
+              return this.axios.post('/object_service/createObject', [type, dataHash]);
+            case 2:
+              response = _context18.v;
+              record = response.data;
+              if (dataHash) {
+                record.data = dataHash;
+              }
+              return _context18.a(2, new _rbt_object["default"](record, this.axios, {
+                isNew: true,
+                websocketClient: this.websocketClient,
+                enableRealtime: options.enableRealtime || false
+              }));
+            case 3:
+              _context18.p = 3;
+              _t11 = _context18.v;
+              return _context18.a(2, this._handleError(_t11));
+          }
+        }, _callee18, this, [[1, 3]]);
+      }));
+      function create(_x10) {
+        return _create.apply(this, arguments);
+      }
+      return create;
+    }()
+    /**
+     * Queries objects of a given type based on specified parameters.
+     *
+     * @param {string} type - The type of object to query, specified as a doctree.typedef.
+     * @param {Object} params - The query parameters, including optional filters and configurations.
+     * @returns {Promise<Array<RbtObject>>} - An array of queried objects as RbtObjects.
+     *
+     * The `params` object can include the following properties:
+     * - where: A SQL-like where clause string for filtering the results.
+     * - orderBy: An object specifying the ordering of the results. It should include:
+     *    - column: The attribute name to sort by. This must be either a column in the @doctree.model schema or an indexed type attribute.
+     *    - direction: The sort direction, either 'ASC' for ascending or 'DESC' for descending.
+     * - limit: An object to control the pagination of results. It includes:
+     *    - offset: The starting point from where to fetch the results.
+     *    - results: The maximum number of results to return.
+     * - resolveReferences: An array of attribute names whose references should be resolved in the returned objects.
+     * - timeout: A numerical value in milliseconds to set a maximum time limit for the query execution.
+     *
+     * Example usage:
+     *   query("<@testuser>", {
+     *     where: 'email="tom@pospa.com"',
+     *     orderBy: { column: 'timeCreated', direction: 'DESC' },
+     *     limit: { offset: 0, results: 50 },
+     *     resolveReferences: ['translatableContent']
+     *   });
+     *
+     * Note: A default orderBy is applied if none is provided, ordering items by 'timeCreated' in descending order.
+     */
+    )
+  }, {
+    key: "query",
+    value: (function () {
+      var _query = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee19(type) {
+        var _this6 = this;
+        var params,
+          paramsKey,
+          defaultOrderBy,
+          defaultLimit,
+          mergedParams,
+          currentTime,
+          cacheEntry,
+          responsePromise,
+          processingPromise,
+          _args19 = arguments,
+          _t12;
+        return _regenerator().w(function (_context19) {
+          while (1) switch (_context19.p = _context19.n) {
+            case 0:
+              params = _args19.length > 1 && _args19[1] !== undefined ? _args19[1] : {};
+              _context19.p = 1;
+              //console.log('RBTAPI.query INIT', type, params);
+              params.type = type;
+
+              // Default ordering and pagination
+              defaultOrderBy = {
+                orderBy: {
+                  column: 'timeCreated',
+                  direction: 'DESC'
+                }
+              };
+              defaultLimit = {
+                limit: {
+                  offset: 0,
+                  results: 50
+                }
+              }; // Merge defaults with provided params
+              mergedParams = _objectSpread(_objectSpread(_objectSpread({}, defaultOrderBy), defaultLimit), params); // Check cache for an existing request
+              currentTime = Date.now();
+              paramsKey = JSON.stringify(mergedParams);
+              cacheEntry = this.requestCache[paramsKey];
+              if (!(cacheEntry && currentTime - cacheEntry.time < 10000)) {
+                _context19.n = 2;
+                break;
+              }
+              return _context19.a(2, cacheEntry.val);
+            case 2:
+              // Create the response promise
+              responsePromise = this.axios.post('/object_service/queryObjects', [mergedParams]); // Cache the promise of processing data, not just the raw response
+              processingPromise = responsePromise.then(function (response) {
+                return _this6._processResponseData(response, params);
+              })["catch"](function (e) {
+                delete _this6.requestCache[paramsKey]; // Ensure cache cleanup on failure
+                //console.log('RBTAPI.query ERROR (Processing)', paramsKey, e);
+                return _this6._handleError(e);
+              }); // Store the promise of the processed data in the cache
+              this.requestCache[paramsKey] = {
+                val: processingPromise,
+                time: currentTime
+              };
+
+              // Await the processing promise for this call to get processed data
+              _context19.n = 3;
+              return processingPromise;
+            case 3:
+              return _context19.a(2, _context19.v);
+            case 4:
+              _context19.p = 4;
+              _t12 = _context19.v;
+              delete this.requestCache[paramsKey]; // Ensure cache cleanup on error
+              //console.log('RBTAPI.query ERROR', paramsKey, e);
+              return _context19.a(2, this._handleError(_t12));
+          }
+        }, _callee19, this, [[1, 4]]);
+      }));
+      function query(_x11) {
+        return _query.apply(this, arguments);
+      }
+      return query;
+    }())
+  }, {
+    key: "_processResponseData",
+    value: function _processResponseData(response) {
+      var _this7 = this;
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (response.data.ok === false) {
+        return this._handleError(response);
+      }
+      if (Array.isArray(response.data.items)) {
+        //console.log('RBTAPI.query RESPONSE PRE', response.data.items);
+
+        // Ensure WebSocket client is available if realtime is requested
+        var websocketClient = this.websocketClient;
+        if (options.enableRealtime && !websocketClient) {
+          console.log('[AgentProviderSync] Creating WebSocket client for realtime objects');
+          websocketClient = this.getWebSocketClient();
+        }
+        console.log('[AgentProviderSync] _processResponseData creating objects with:', {
+          enableRealtime: options.enableRealtime || false,
+          hasWebSocketClient: !!websocketClient,
+          itemCount: response.data.items.length
+        });
+        response.data.items = response.data.items.map(function (record) {
+          return new _rbt_object["default"](record, _this7.axios, {
+            websocketClient: websocketClient,
+            enableRealtime: options.enableRealtime || false
+          });
+        });
+      }
+
+      //console.log('RBTAPI.query RESPONSE POST', response.data.items);
+      return response.data.items;
+    }
+
+    /**
+     * Loads one or multiple objects of a given type by their IDs.
+     *
+     * @param {string} type - The type of object to load.
+     * @param {Array<string>|string} ids - The ID(s) of the object(s) to load.
+     * 
+     * @returns {Promise<RbtObject|RbtObject[]>} - The loaded object(s) as RbtObject(s).
+     */
+  }, {
+    key: "load",
+    value: (function () {
+      var _load = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee21(type, ids) {
+        var _this8 = this;
+        var params,
+          mergedParams,
+          cachedObjects,
+          missingIds,
+          _iterator2,
+          _step2,
+          id,
+          _cacheKey,
+          cached,
+          hitLogKey,
+          loadedObjects,
+          bulkMissLogKey,
+          _iterator3,
+          _step3,
+          obj,
+          cacheKey,
+          setLogKey,
+          result,
+          _iterator4,
+          _step4,
+          _id,
+          _cacheKey2,
+          _obj,
+          _cacheKey3,
+          _cached,
+          _hitLogKey,
+          pendingKey,
+          missLogKey,
+          loadPromise,
+          _args21 = arguments,
+          _t13;
+        return _regenerator().w(function (_context21) {
+          while (1) switch (_context21.p = _context21.n) {
+            case 0:
+              params = _args21.length > 2 && _args21[2] !== undefined ? _args21[2] : {};
+              if (type == '<@iac.user>') {
+                debugger;
+              }
+              _context21.p = 1;
+              if (!Array.isArray(ids)) {
+                _context21.n = 4;
+                break;
+              }
+              // For array requests, check cache for each ID and only load missing ones
+              cachedObjects = [];
+              missingIds = [];
+              _iterator2 = _createForOfIteratorHelper(ids);
+              try {
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  id = _step2.value;
+                  _cacheKey = "".concat(type, ":").concat(id);
+                  cached = this._objectCache.get(_cacheKey);
+                  if (cached) {
+                    // Only log cache hits once per object to reduce spam
+                    hitLogKey = "hit:".concat(_cacheKey);
+                    if (!this._loggedCacheEvents.has(hitLogKey)) {
+                      console.log('[AgentProviderSync] 🎯 roboto.load cache HIT:', {
+                        type: type,
+                        id: id,
+                        hasRealtime: !!cached._realtime,
+                        requestedRealtime: !!params.enableRealtime
+                      });
+                      this._loggedCacheEvents.add(hitLogKey);
+                    }
+
+                    // If realtime is requested but cached object doesn't have it, upgrade it
+                    if (params.enableRealtime && !cached._realtime) {
+                      console.log('[AgentProviderSync] 🔄 Upgrading cached object to realtime:', {
+                        type: type,
+                        id: id
+                      });
+                      cached._initRealtime();
+                    }
+                    cachedObjects.push(cached);
+                  } else {
+                    missingIds.push(id);
+                  }
+                }
+
+                // Load missing objects
+              } catch (err) {
+                _iterator2.e(err);
+              } finally {
+                _iterator2.f();
+              }
+              loadedObjects = [];
+              if (!(missingIds.length > 0)) {
+                _context21.n = 3;
+                break;
+              }
+              // Only log bulk cache miss once
+              bulkMissLogKey = "bulk-miss:".concat(type, ":").concat(missingIds.join(','));
+              if (!this._loggedCacheEvents.has(bulkMissLogKey)) {
+                console.log('[AgentProviderSync] 📦 roboto.load cache MISS, loading:', {
+                  type: type,
+                  ids: missingIds
+                });
+                this._loggedCacheEvents.add(bulkMissLogKey);
+              }
+              mergedParams = _objectSpread(_objectSpread({}, params), {}, {
+                where: "id IN (\"".concat(missingIds.join("\",\""), "\")")
+              });
+              _context21.n = 2;
+              return this.query(type, mergedParams);
+            case 2:
+              loadedObjects = _context21.v;
+              // Cache the newly loaded objects
+              _iterator3 = _createForOfIteratorHelper(loadedObjects);
+              try {
+                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                  obj = _step3.value;
+                  cacheKey = "".concat(type, ":").concat(obj.id);
+                  this._objectCache.set(cacheKey, obj);
+
+                  // Only log cache set once per object to reduce spam
+                  setLogKey = "set:".concat(cacheKey);
+                  if (!this._loggedCacheEvents.has(setLogKey)) {
+                    console.log('[AgentProviderSync] 💾 roboto.load cached object:', {
+                      type: type,
+                      id: obj.id
+                    });
+                    this._loggedCacheEvents.add(setLogKey);
+                  }
+                }
+              } catch (err) {
+                _iterator3.e(err);
+              } finally {
+                _iterator3.f();
+              }
+            case 3:
+              // Return combined results in original order
+              result = [];
+              _iterator4 = _createForOfIteratorHelper(ids);
+              try {
+                for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                  _id = _step4.value;
+                  _cacheKey2 = "".concat(type, ":").concat(_id);
+                  _obj = this._objectCache.get(_cacheKey2);
+                  if (_obj) {
+                    // Ensure realtime is enabled if requested
+                    if (params.enableRealtime && !_obj._realtime) {
+                      _obj._initRealtime();
+                    }
+                    result.push(_obj);
+                  }
+                }
+              } catch (err) {
+                _iterator4.e(err);
+              } finally {
+                _iterator4.f();
+              }
+              return _context21.a(2, result);
+            case 4:
+              // For single object requests, check cache first
+              _cacheKey3 = "".concat(type, ":").concat(ids);
+              _cached = this._objectCache.get(_cacheKey3);
+              if (!_cached) {
+                _context21.n = 5;
+                break;
+              }
+              // Only log cache hits once per object to reduce spam
+              _hitLogKey = "hit:".concat(_cacheKey3);
+              if (!this._loggedCacheEvents.has(_hitLogKey) || console.log('[AgentProviderSync] 🎯 roboto.load cache HIT:', {
+                type: type,
+                id: ids,
+                hasRealtime: !!_cached._realtime,
+                requestedRealtime: !!params.enableRealtime
+              })) {
+                this._loggedCacheEvents.add(_hitLogKey);
+              }
+
+              // If realtime is requested but cached object doesn't have it, upgrade it
+              if (params.enableRealtime && !_cached._realtime) {
+                console.log('[AgentProviderSync] 🔄 Upgrading cached object to realtime:', {
+                  type: type,
+                  id: ids
+                });
+                _cached._initRealtime();
+              }
+              return _context21.a(2, _cached);
+            case 5:
+              // Check if we're already loading this object
+              pendingKey = "".concat(type, ":").concat(ids);
+              if (!this._pendingLoads.has(pendingKey)) {
+                _context21.n = 7;
+                break;
+              }
+              _context21.n = 6;
+              return this._pendingLoads.get(pendingKey);
+            case 6:
+              return _context21.a(2, _context21.v);
+            case 7:
+              // Only log cache miss once per object to reduce spam
+              missLogKey = "miss:".concat(_cacheKey3);
+              if (!this._loggedCacheEvents.has(missLogKey)) {
+                console.log('[AgentProviderSync] 📦 roboto.load cache MISS, loading:', {
+                  type: type,
+                  id: ids
+                });
+                this._loggedCacheEvents.add(missLogKey);
+              }
+
+              // Create the loading promise and store it to prevent duplicate requests
+              loadPromise = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee20() {
+                var res, _obj2, _setLogKey;
+                return _regenerator().w(function (_context20) {
+                  while (1) switch (_context20.p = _context20.n) {
+                    case 0:
+                      _context20.p = 0;
+                      mergedParams = _objectSpread(_objectSpread({}, params), {}, {
+                        where: "id=\"".concat(ids, "\"")
+                      });
+                      _context20.n = 1;
+                      return _this8.query(type, mergedParams);
+                    case 1:
+                      res = _context20.v;
+                      _obj2 = res[0];
+                      if (_obj2) {
+                        // Cache the loaded object
+                        _this8._objectCache.set(_cacheKey3, _obj2);
+
+                        // Only log cache set once per object to reduce spam
+                        _setLogKey = "set:".concat(_cacheKey3);
+                        if (!_this8._loggedCacheEvents.has(_setLogKey)) {
+                          console.log('[AgentProviderSync] 💾 roboto.load cached object:', {
+                            type: type,
+                            id: ids
+                          });
+                          _this8._loggedCacheEvents.add(_setLogKey);
+                        }
+                      }
+                      return _context20.a(2, _obj2);
+                    case 2:
+                      _context20.p = 2;
+                      // Remove from pending loads
+                      _this8._pendingLoads["delete"](pendingKey);
+                      return _context20.f(2);
+                    case 3:
+                      return _context20.a(2);
+                  }
+                }, _callee20, null, [[0,, 2, 3]]);
+              }))(); // Store the promise so other concurrent requests can await it
+              this._pendingLoads.set(pendingKey, loadPromise);
+              _context21.n = 8;
+              return loadPromise;
+            case 8:
+              return _context21.a(2, _context21.v);
+            case 9:
+              _context21.n = 11;
+              break;
+            case 10:
+              _context21.p = 10;
+              _t13 = _context21.v;
+              return _context21.a(2, this._handleError(_t13));
+            case 11:
+              return _context21.a(2);
+          }
+        }, _callee21, this, [[1, 10]]);
+      }));
+      function load(_x12, _x13) {
+        return _load.apply(this, arguments);
+      }
+      return load;
+    }()
+    /**
+     * Clears the object cache. Useful for cache invalidation.
+     * @param {string} type - Optional object type to clear. If not provided, clears all.
+     * @param {string} id - Optional object ID to clear. If not provided with type, clears all objects of that type.
+     */
+    )
+  }, {
+    key: "clearCache",
+    value: function clearCache() {
+      var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      var id = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      if (type && id) {
+        // Clear specific object
+        var cacheKey = "".concat(type, ":").concat(id);
+        var removed = this._objectCache["delete"](cacheKey);
+
+        // Clear related log tracking
+        this._loggedCacheEvents["delete"]("hit:".concat(cacheKey));
+        this._loggedCacheEvents["delete"]("miss:".concat(cacheKey));
+        this._loggedCacheEvents["delete"]("set:".concat(cacheKey));
+        console.log('[AgentProviderSync] 🗑️ roboto.clearCache specific object:', {
+          type: type,
+          id: id,
+          removed: removed
+        });
+      } else if (type) {
+        // Clear all objects of a specific type
+        var removedCount = 0;
+        var _iterator5 = _createForOfIteratorHelper(this._objectCache),
+          _step5;
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            var _step5$value = _slicedToArray(_step5.value, 1),
+              key = _step5$value[0];
+            if (key.startsWith("".concat(type, ":"))) {
+              this._objectCache["delete"](key);
+              removedCount++;
+            }
+          }
+
+          // Clear related log tracking for this type
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+        var _iterator6 = _createForOfIteratorHelper(this._loggedCacheEvents),
+          _step6;
+        try {
+          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+            var logKey = _step6.value;
+            if (logKey.includes("".concat(type, ":"))) {
+              this._loggedCacheEvents["delete"](logKey);
+            }
+          }
+        } catch (err) {
+          _iterator6.e(err);
+        } finally {
+          _iterator6.f();
+        }
+        console.log('[AgentProviderSync] 🗑️ roboto.clearCache by type:', {
+          type: type,
+          removedCount: removedCount
+        });
+      } else {
+        // Clear all cached objects
+        var size = this._objectCache.size;
+        this._objectCache.clear();
+        this._loggedCacheEvents.clear();
+        this._pendingLoads.clear();
+        console.log('[AgentProviderSync] 🗑️ roboto.clearCache all objects:', {
+          clearedCount: size
+        });
+      }
+    }
+
+    /**
+     * Gets cache status for debugging
+     * @returns {Object} Cache status information
+     */
+  }, {
+    key: "getCacheStatus",
+    value: function getCacheStatus() {
+      var cacheEntries = Array.from(this._objectCache.entries()).map(function (_ref6) {
+        var _obj$_internalData;
+        var _ref7 = _slicedToArray(_ref6, 2),
+          key = _ref7[0],
+          obj = _ref7[1];
+        return {
+          key: key,
+          id: obj.id,
+          type: ((_obj$_internalData = obj._internalData) === null || _obj$_internalData === void 0 ? void 0 : _obj$_internalData.type) || 'unknown'
+        };
+      });
+      var pendingLoads = Array.from(this._pendingLoads.keys());
+      return {
+        cacheSize: this._objectCache.size,
+        pendingLoads: pendingLoads.length,
+        loggedEvents: this._loggedCacheEvents.size,
+        entries: cacheEntries,
+        pendingKeys: pendingLoads
+      };
+    }
+
+    /**
+     * Makes a POST request to a specific endpoint to run a task and handle progress updates.
+     *
+     * @param params.id (optional) IF the client is MONITORING the job with WS ClientMonitor, 
+     *                             the client should generate a jobId and connect to the ClientMonitor
+     *                             BEFORE starting the job, to make sure no messages are missed - 
+     *                             otherwise we'd have to delay the task start.
+     *                             
+     * @param {Object} params - The parameters to be sent in the POST request.
+     * @param {Object} callbacks - An object containing callback functions for progress and error handling.
+     * 
+     * The function expects a response in the following format:
+     * {
+     *   ok: boolean, // Indicates if the request was successful or not
+     *   jobId: string, // The job identifier
+     *   status: string // Can be 'RUNNING', 'DONE', or 'ERROR'
+     * }
+     */
+  }, {
+    key: "runTask",
+    value: (function () {
+      var _runTask = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee22() {
+        var params,
+          callbacks,
+          onProgress,
+          onError,
+          onStopped,
+          onWaiting,
+          onDone,
+          response,
+          ok,
+          jobId,
+          status,
+          message,
+          output,
+          _args22 = arguments,
+          _t14;
+        return _regenerator().w(function (_context22) {
+          while (1) switch (_context22.p = _context22.n) {
+            case 0:
+              params = _args22.length > 0 && _args22[0] !== undefined ? _args22[0] : {};
+              callbacks = _args22.length > 1 && _args22[1] !== undefined ? _args22[1] : {};
+              onProgress = callbacks.onProgress, onError = callbacks.onError, onStopped = callbacks.onStopped, onWaiting = callbacks.onWaiting, onDone = callbacks.onDone;
+              _context22.p = 1;
+              _context22.n = 2;
+              return this.post('/task_service/runChain', params);
+            case 2:
+              response = _context22.v;
+              if (response) {
+                _context22.n = 3;
+                break;
+              }
+              throw new Error('Invalid server response');
+            case 3:
+              // Validate response structure
+              ok = response.ok, jobId = response.jobId, status = response.status, message = response.message, output = response.output;
+              if (!(!ok || typeof jobId !== 'string' || typeof status !== 'string')) {
+                _context22.n = 4;
+                break;
+              }
+              throw new Error('Invalid response structure');
+            case 4:
+              // If the task is still in progress, start polling for updates
+              if (status === 'RUNNING' || status === 'SCHEDULED' || status === 'QUEUED' || status === 'STOPPING') {
+                this.pollTaskProgress(jobId, callbacks);
+              }
+              if (status === 'ERROR' && onError) {
+                // Provide the current progress to the callback function
+                onError(response);
+              }
+              if (status === 'STOPPED' && onStopped) {
+                // Provide the current progress to the callback function
+                onStopped(response);
+              }
+              if (status === 'WAITING' && onWaiting) {
+                // Provide the current progress to the callback function
+                onWaiting(response);
+              }
+              if (status === 'DONE' && onDone) {
+                // Provide the current progress to the callback function
+                //console.log('Finish (request) ',response);
+                onDone(response);
+              }
+              return _context22.a(2, {
+                ok: ok,
+                jobId: jobId,
+                status: status,
+                message: message,
+                output: output
+              });
+            case 5:
+              _context22.p = 5;
+              _t14 = _context22.v;
+              if (typeof onError === 'function') {
+                onError(_t14);
+              } else {
+                console.error('Error in runTask:', _t14);
+              }
+              return _context22.a(2, {
+                ok: false,
+                jobId: null,
+                status: 'ERROR',
+                error: _t14.message
+              });
+          }
+        }, _callee22, this, [[1, 5]]);
+      }));
+      function runTask() {
+        return _runTask.apply(this, arguments);
+      }
+      return runTask;
+    }())
+  }, {
+    key: "stopJob",
+    value: function () {
+      var _stopJob = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee23() {
+        var params,
+          callbacks,
+          response,
+          _args23 = arguments,
+          _t15;
+        return _regenerator().w(function (_context23) {
+          while (1) switch (_context23.p = _context23.n) {
+            case 0:
+              params = _args23.length > 0 && _args23[0] !== undefined ? _args23[0] : {};
+              callbacks = _args23.length > 1 && _args23[1] !== undefined ? _args23[1] : {};
+              _context23.p = 1;
+              _context23.n = 2;
+              return this.post('/task_service/stopJob', params);
+            case 2:
+              response = _context23.v;
+              if (response) {
+                _context23.n = 3;
+                break;
+              }
+              throw new Error('Invalid server response');
+            case 3:
+              return _context23.a(2, true);
+            case 4:
+              _context23.p = 4;
+              _t15 = _context23.v;
+              throw 'Error in stopJob';
+            case 5:
+              return _context23.a(2);
+          }
+        }, _callee23, this, [[1, 4]]);
+      }));
+      function stopJob() {
+        return _stopJob.apply(this, arguments);
+      }
+      return stopJob;
+    }()
+    /**
+     * Polls the progress of a long-running task.
+     * 
+     * @param {string} jobId - The ID of the job to poll for progress.
+     * @param {function} onProgress - Callback function that receives progress updates.
+     * 
+     * The function periodically sends GET requests to check the task's progress
+     * and reports back via the provided callback function . The polling stops when
+     * the task is completed or an error occurs.
+     */
+  }, {
+    key: "pollTaskProgress",
+    value: (function () {
+      var _pollTaskProgress = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee25(jobId, callbacks) {
+        var _this9 = this;
+        var onProgress, onError, onStopped, onWaiting, onDone, _callbacks$pollingInt, pollingInterval, _checkProgress, _t16;
+        return _regenerator().w(function (_context25) {
+          while (1) switch (_context25.p = _context25.n) {
+            case 0:
+              onProgress = callbacks.onProgress, onError = callbacks.onError, onStopped = callbacks.onStopped, onWaiting = callbacks.onWaiting, onDone = callbacks.onDone, _callbacks$pollingInt = callbacks.pollingInterval, pollingInterval = _callbacks$pollingInt === void 0 ? 2000 : _callbacks$pollingInt;
+              _context25.p = 1;
+              _checkProgress = /*#__PURE__*/function () {
+                var _ref8 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee24() {
+                  var response;
+                  return _regenerator().w(function (_context24) {
+                    while (1) switch (_context24.n) {
+                      case 0:
+                        _context24.n = 1;
+                        return _this9.get("/task_service/pollChainProgress", {
+                          jobId: jobId
+                        });
+                      case 1:
+                        response = _context24.v;
+                        // If the task is still in progress, start polling for updates
+                        if (response.status === 'DONE' && onDone) {
+                          // Provide the current progress to the callback function
+                          //console.log('Finish (progress) ',response);
+                          onDone(response);
+                        }
+                        if (response.status === 'ERROR' && onError) {
+                          // Provide the current progress to the callback function
+                          onError(response);
+                        }
+                        if (response.status === 'STOPPED' && onStopped) {
+                          // Provide the current progress to the callback function
+                          onStopped(response);
+                        }
+                        if (response.status === 'WAITING' && onWaiting) {
+                          // Provide the current progress to the callback function
+                          onWaiting(response);
+                        }
+
+                        // Provide the current progress to the callback function
+                        if (response.status == 'RUNNING') {
+                          onProgress(response);
+                        }
+
+                        // Continue polling if the status is 'RUNNING' or STOPPING
+                        if (['RUNNING', 'STOPPING'].includes(response.status)) {
+                          setTimeout(_checkProgress, pollingInterval); // Poll every 2 seconds
+                        }
+                      case 2:
+                        return _context24.a(2);
+                    }
+                  }, _callee24);
+                }));
+                return function checkProgress() {
+                  return _ref8.apply(this, arguments);
+                };
+              }();
+              _checkProgress();
+              _context25.n = 3;
+              break;
+            case 2:
+              _context25.p = 2;
+              _t16 = _context25.v;
+              return _context25.a(2, this._handleError(_t16));
+            case 3:
+              return _context25.a(2);
+          }
+        }, _callee25, this, [[1, 2]]);
+      }));
+      function pollTaskProgress(_x14, _x15) {
+        return _pollTaskProgress.apply(this, arguments);
+      }
+      return pollTaskProgress;
+    }()
+    /**
+     * Performs a GET request to the specified endpoint.
+     * 
+     * This method uses the Axios instance to make an authenticated GET request.
+     * The `authtoken` stored in the class instance is included in the request headers
+     * for authorization. It handles any errors and returns the response data.
+     *
+     * @param {string} endpoint - The endpoint URL to which the GET request is made.
+     * @param {Object} [params={}] - Optional parameters to be sent with the request.
+     * @returns {Promise<Object>} - The response data from the API.
+     */
+    )
+  }, {
+    key: "get",
+    value: (function () {
+      var _get = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee26(endpoint) {
+        var params,
+          headers,
+          response,
+          _args26 = arguments,
+          _t17;
+        return _regenerator().w(function (_context26) {
+          while (1) switch (_context26.p = _context26.n) {
+            case 0:
+              params = _args26.length > 1 && _args26[1] !== undefined ? _args26[1] : {};
+              _context26.p = 1;
+              // Add the authToken to the headers
+              headers = {
+                authtoken: this.authtoken
+              }; // Make the GET request using Axios
+              _context26.n = 2;
+              return this.axios.get(endpoint, {
+                params: params,
+                headers: headers
+              });
+            case 2:
+              response = _context26.v;
+              if (!(response.data.ok === false)) {
+                _context26.n = 3;
+                break;
+              }
+              return _context26.a(2, this._handleError(response));
+            case 3:
+              return _context26.a(2, response.data);
+            case 4:
+              _context26.p = 4;
+              _t17 = _context26.v;
+              return _context26.a(2, this._handleError(_t17));
+          }
+        }, _callee26, this, [[1, 4]]);
+      }));
+      function get(_x16) {
+        return _get.apply(this, arguments);
+      }
+      return get;
+    }()
+    /**
+     * Performs a POST request to the specified endpoint.
+     * 
+     * This method uses the Axios instance to make an authenticated POST request.
+     * It includes the `authtoken` in the request headers for authorization. The method
+     * sends the provided data as the request body. It handles any errors and returns
+     * the response data.
+     *
+     * @param {string} endpoint - The endpoint URL to which the POST request is made.
+     * @param {Object} [data={}] - Data to be sent in the body of the POST request.
+     * @returns {Promise<Object>} - The response data from the API.
+     */
+    )
+  }, {
+    key: "post",
+    value: (function () {
+      var _post = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee27(endpoint) {
+        var data,
+          headers,
+          response,
+          _args27 = arguments,
+          _t18;
+        return _regenerator().w(function (_context27) {
+          while (1) switch (_context27.p = _context27.n) {
+            case 0:
+              data = _args27.length > 1 && _args27[1] !== undefined ? _args27[1] : {};
+              _context27.p = 1;
+              // Add the authToken to the headers
+              headers = {
+                authtoken: this.authtoken
+              }; // Make the POST request using Axios
+              _context27.n = 2;
+              return this.axios.post(endpoint, data, {
+                headers: headers
+              });
+            case 2:
+              response = _context27.v;
+              if (!(response.data.ok === false)) {
+                _context27.n = 3;
+                break;
+              }
+              return _context27.a(2, this._handleError(response));
+            case 3:
+              return _context27.a(2, response.data);
+            case 4:
+              _context27.p = 4;
+              _t18 = _context27.v;
+              return _context27.a(2, this._handleError(_t18));
+          }
+        }, _callee27, this, [[1, 4]]);
+      }));
+      function post(_x17) {
+        return _post.apply(this, arguments);
+      }
+      return post;
+    }())
+  }, {
+    key: "setErrorHandler",
+    value: function setErrorHandler(customErrorHandler) {
+      this.customErrorHandler = customErrorHandler;
+    }
+  }, {
+    key: "_handleError",
+    value: function _handleError(err) {
+      // Invoke the custom error handler if provided
+      if (this.customErrorHandler) {
+        var res = this.customErrorHandler(err);
+        if (res) return;
+      }
+      if (_lodash["default"].isObject(err) && _lodash["default"].get(err, 'response')) {
+        if (err.response) {
+          console.log('Error response:', {
+            data: err.response.data,
+            status: err.response.status,
+            headers: err.response.headers
+          });
+        }
+        var msg = _lodash["default"].get(err, 'response.data.message', 'Error in API response');
+        if (msg.key) {
+          //throw new Error(msg.key);
+          throw {
+            message: msg.key
+          };
+        } else {
+          //throw new Error(msg);
+          throw {
+            message: msg
+          };
+        }
+      } else {
+        //throw new Error(err.message || 'Unknown error');
+        throw {
+          code: err.code,
+          message: err.message
+        } || {
+          message: err
+        } || {
+          message: 'Unknown error'
+        };
+      }
+    }
+  }]);
+}();