@koi-design/callkit 1.0.26-beta.1 → 1.0.26

package/dist/index.js

@@ -36,6 +36,7 @@ var import_blueimp_md5 = __toESM(require("blueimp-md5"));
 
 // package/axios.ts
 var import_axios = __toESM(require("axios"));
+var import_axios_retry = __toESM(require("axios-retry"));
 var instance = import_axios.default.create({
   headers: {
     "Content-Type": "application/x-www-form-urlencoded"
@@ -46,85 +47,26 @@ instance.interceptors.response.use(
   (response) => response.data,
   (error) => Promise.reject(error)
 );
+(0, import_axios_retry.default)(instance, {
+  retries: 3,
+  // Maximum number of retries, default is 3
+  retryDelay: (retryCount, error) => {
+    console.log(
+      `AJAX Retrying attempt ${retryCount}, error: ${error?.message}`
+    );
+    return retryCount * 1e3;
+  },
+  retryCondition: (error) => {
+    if (!error.response)
+      return true;
+    return error.response.status < 200 || error.response.status >= 300;
+  },
+  shouldResetTimeout: true
+  // Whether to reset axios timeout on retry
+});
 var request = (config) => instance.request(config);
 var axios_default = request;
 
-// package/api.ts
-var Api = class {
-  callKit;
-  constructor(callKit) {
-    this.callKit = callKit;
-  }
-  async login(params) {
-    return this.post({
-      url: "/auth/agentUser/login",
-      method: "post",
-      data: params
-    });
-  }
-  async loginOut(params) {
-    return this.post({
-      url: "/auth/agentUser/loginOut",
-      method: "post",
-      data: params
-    });
-  }
-  /**
-   *
-   * @param params agentId userStatus
-   * @description userStatus: Logout(1, "unregistered"), Free(2, "free"), Break(3, "nap"), Busy(4, "busy")
-   * @returns
-   */
-  async setUserStatus(params) {
-    return this.post({
-      url: "/agent/user/changeStatus",
-      method: "post",
-      data: params
-    });
-  }
-  async measureRTT(config) {
-    this.callKit.logger.debug(`Request ${config.url}:`, config.data);
-    return axios_default(config);
-  }
-  async post(config) {
-    this.callKit.logger.debug(`Request ${config.url}:`, config.data);
-    const { userInfo, host } = this.callKit.config.getConfig();
-    const { sessionId } = userInfo;
-    config.url = `${host}${config.url}`;
-    config.headers = {
-      ...config.headers,
-      "Content-Type": "application/x-www-form-urlencoded"
-    };
-    if (config.headers["Content-Type"] === "application/x-www-form-urlencoded") {
-      config.data = new URLSearchParams(config.data).toString();
-    }
-    if (sessionId) {
-      config.headers.sessionId = sessionId;
-    }
-    const res = await axios_default(config).catch(() => {
-      this.callKit.config.reset();
-    });
-    if (!res) {
-      this.callKit.config.reset();
-      throw new Error("Network error");
-    }
-    const { code, data, message } = res;
-    if (code === "000000") {
-      return data;
-    }
-    if (code === "100013") {
-      this.callKit.config.reset();
-    }
-    throw new Error(message ?? "Request failed");
-  }
-  async get(config) {
-    return this.post({
-      ...config,
-      method: "get"
-    });
-  }
-};
-
 // package/const.ts
 var UserStatus = {
   /**
@@ -211,6 +153,10 @@ var KitEvent = {
    * Server initiated call
    */
   KIT_INVITE: "invite",
+  /**
+   * Server outgoing initiated call
+   */
+  KIT_OUTGOING_INVITE: "outgoingInvite",
   // /**
   //  * Referral
   //  */
@@ -255,14 +201,10 @@ var KitEvent = {
    * User status change
    */
   USER_STATUS_CHANGE: "userStatusChange",
-  /**
-   * SOCKET CONNECT EVENT
-   */
   CONNECT_EVENT: "CONNECT_EVENT",
-  /**
-   * NETWORK EVENT
-   */
-  NETWORK_EVENT: "NETWORK_EVENT"
+  SIP_REGISTERER_EVENT: "sipRegistererEvent",
+  SIP_SESSION_EVENT: "sipSessionEvent",
+  USER_STATUS_CHANGE_STEP: "userStatusChangeStep"
 };
 var ErrorCode = {
   /**
@@ -397,7 +339,9 @@ var SocketSendEvent = {
   /**
    * AGENT_TRANSFER
    */
-  HANG_UP_REASON: "HANG_UP_REASON"
+  HANG_UP_REASON: "HANG_UP_REASON",
+  ACK: "ACK",
+  SDK_LOG: "SDK_LOG"
 };
 var SocketReceiveEvent = {
   /**
@@ -461,6 +405,10 @@ var EncryptionMethod = {
   NONE: "NONE",
   INTERNAL: "INTERNAL"
 };
+var LogGatherEnum = {
+  ENABLE: 1,
+  DISABLE: 2
+};
 var constrainsDefault = {
   audio: {
     autoGainControl: true,
@@ -478,19 +426,330 @@ var CallSourceType = {
 };
 var ConnectEvent = {
   SIP_CONNECT_ERROR: "SIP_CONNECT_ERROR",
+  SIP_RECONNECT_START: "SIP_RECONNECT_START",
   SIP_RECONNECT_ERROR: "SIP_RECONNECT_ERROR",
   SIP_RECONNECT_SUCCESS: "SIP_RECONNECT_SUCCESS",
+  SIP_RECONNECTING: "SIP_RECONNECTING",
+  INCALL_NOT_CONNECTED: "INCALL_NOT_CONNECTED",
   INCALL_CONNECT_ERROR: "INCALL_CONNECT_ERROR",
+  INCALL_RECONNECT_START: "INCALL_RECONNECT_START",
   INCALL_RECONNECT_ERROR: "INCALL_RECONNECT_ERROR",
   INCALL_RECONNECT_SUCCESS: "INCALL_RECONNECT_SUCCESS",
+  INCALL_RECONNECTING: "INCALL_RECONNECTING",
   OPTIONS_HEARTBEAT_EXPIRED: "OPTIONS_HEARTBEAT_EXPIRED",
-  USER_AGENT_START_ERROR: "USER_AGENT_START_ERROR",
-  CONNECT_CLOSING: "CONNECT_CLOSING",
-  CONNECT_CLOSING_END: "CONNECT_CLOSING_END"
+  USER_AGENT_START_ERROR: "USER_AGENT_START_ERROR"
+};
+var SipRegistererEvent = {
+  Initial: "Initial",
+  Registered: "Registered",
+  Unregistered: "Unregistered",
+  Terminated: "Terminated"
+};
+var SipSessionEvent = {
+  Establishing: "Establishing",
+  Established: "Established",
+  Terminating: "Terminating",
+  Terminated: "Terminated"
+};
+var UserStatusChangeStepEnum = {
+  UserStatusChangeStart: "UserStatusChangeStart",
+  UserStatusChangeEnd: "UserStatusChangeEnd",
+  UserStatusChangeError: "UserStatusChangeError",
+  // login
+  UserStatusChangeLoginStart: "UserStatusChangeLoginStart",
+  UserStatusChangeLoginEnd: "UserStatusChangeLoginEnd",
+  UserStatusChangeLoginError: "UserStatusChangeLoginError",
+  // logout
+  UserStatusChangeLoginOutStart: "UserStatusChangeLoginOutStart",
+  UserStatusChangeLoginOutEnd: "UserStatusChangeLoginOutEnd",
+  UserStatusChangeLoginOutError: "UserStatusChangeLoginOutError"
+};
+var LogDataEnum = {
+  SIP: "sip",
+  INCALL: "incall",
+  AJAX: "ajax",
+  ERROR: "error",
+  RECONNECT: "reconnect",
+  ALL: "all"
 };
-var NetWorkEvent = {
-  RTT_MEASURE_SUCCESS: "RTT_MEASURE_SUCCESS",
-  RTT_MEASURE_FAILED: "RTT_MEASURE_FAILED"
+
+// package/logger.ts
+var import_json_stringify_safe = __toESM(require("json-stringify-safe"));
+function getLevel(level) {
+  return LoggerLevelMap[level];
+}
+var Logger = class {
+  prefix = "CallKit";
+  level = "debug";
+  logData = {
+    sip: [],
+    incall: [],
+    ajax: [],
+    error: [],
+    reconnect: [],
+    all: []
+  };
+  sendSdkLogData = [];
+  callKit;
+  constructor(callKit, level) {
+    this.callKit = callKit;
+    this.level = level || "debug";
+    this.logData = {
+      sip: [],
+      incall: [],
+      ajax: [],
+      error: [],
+      reconnect: [],
+      all: []
+    };
+    this.sendSdkLogData = [];
+  }
+  static formatStrLog(logObj) {
+    const {
+      type = "info"
+      // 默认等级
+    } = logObj;
+    const time = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
+    const level = String(type).toUpperCase().padEnd(5, " ");
+    const tagStr = logObj.typeag ? `[${logObj.type}]` : "";
+    const msg = JSON.stringify(logObj);
+    return `${time} [${level}] ${tagStr} ${msg}`.trim();
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  debug(msg, extra) {
+    if (getLevel(this.level) >= getLevel("debug")) {
+      this.output("blue")(msg, extra);
+    }
+  }
+  log(msg, extra) {
+    if (getLevel(this.level) >= getLevel("log")) {
+      this.output("green")(msg, extra);
+    }
+  }
+  warn(msg, extra) {
+    if (getLevel(this.level) >= getLevel("warn")) {
+      this.output("orange")(msg, extra);
+    }
+  }
+  error(msg, extra) {
+    const message = msg?.message ?? msg;
+    if (getLevel(this.level) >= getLevel("error")) {
+      this.output("red")(message, extra);
+    }
+    const { errCode, ...rest } = extra;
+    const errorCode = errCode ?? ErrorCode.UNKNOWN_ERROR;
+    this.callKit.trigger(KitEvent.KIT_ERROR, {
+      code: errorCode,
+      msg: message,
+      data: rest
+    });
+    this.callKit.reset();
+    const error = new Error(message);
+    error.name = "CallKitError";
+    error.code = errorCode;
+    error.data = rest;
+    throw error;
+  }
+  addLogData(type, data = {}) {
+    this.callKit.user.sendSdkLog({
+      ...data,
+      type,
+      timestamp: (/* @__PURE__ */ new Date()).valueOf(),
+      time: (/* @__PURE__ */ new Date()).toLocaleString()
+    });
+    if (!this.callKit.config.isLogGatherEnable()) {
+      return;
+    }
+    let logData = {
+      type,
+      timestamp: (/* @__PURE__ */ new Date()).valueOf(),
+      time: (/* @__PURE__ */ new Date()).toLocaleString(),
+      data: ""
+    };
+    if (type === LogDataEnum.INCALL) {
+      logData.data = (0, import_json_stringify_safe.default)({
+        // customField
+        callKitSocketFrom: data?.callKitSocketFrom,
+        type: data?.ev.type || data?.type,
+        data: data?.ev.data || data?.data,
+        // message
+        origin: data?.ev.origin || data?.origin,
+        lastEventId: data?.ev.lastEventId || data?.lastEventId,
+        isTrusted: data?.ev.isTrusted || data?.isTrusted,
+        // close
+        code: data?.ev.code || data?.code,
+        reason: data?.ev.reason || data?.reason,
+        wasClean: data?.ev.wasClean || data?.wasClean
+      });
+    } else {
+      logData = (0, import_json_stringify_safe.default)(data);
+    }
+    switch (type) {
+      case LogDataEnum.SIP:
+        this.logData.sip.push(logData);
+        this.logData.all.push(logData);
+        break;
+      case LogDataEnum.INCALL:
+        this.logData.incall.push(logData);
+        this.logData.all.push(logData);
+        break;
+      case LogDataEnum.AJAX:
+        this.logData.ajax.push(logData);
+        this.logData.all.push(logData);
+        break;
+      case LogDataEnum.RECONNECT:
+        this.logData.reconnect.push(logData);
+        this.logData.all.push(logData);
+        break;
+      case LogDataEnum.ERROR:
+        this.logData.error.push(logData);
+        this.logData.all.push(logData);
+        break;
+      default:
+        this.logData.all.push(logData);
+        break;
+    }
+  }
+  output(color) {
+    return (msg, extra = {}) => {
+      const now = /* @__PURE__ */ new Date();
+      if (Object.keys(extra).length > 0) {
+        console.log(
+          `%c[${this.prefix}] %c ${msg} %o %c ${now.toLocaleString()}`,
+          `color: ${color};`,
+          "color:block;",
+          extra,
+          "color:#999;"
+        );
+      } else {
+        console.log(
+          `%c[${this.prefix}] %c ${msg} %c ${now.toLocaleString()}`,
+          `color: ${color};`,
+          "color:block;",
+          "color:#999;"
+        );
+      }
+    };
+  }
+};
+
+// package/api.ts
+var Api = class {
+  callKit;
+  constructor(callKit) {
+    this.callKit = callKit;
+  }
+  async login(params) {
+    return this.post({
+      url: "/auth/agentUser/login",
+      method: "post",
+      data: params
+    });
+  }
+  async loginOut(params) {
+    return this.post({
+      url: "/auth/agentUser/loginOut",
+      method: "post",
+      data: params
+    });
+  }
+  /**
+   * @description sdkLog
+   * @param params
+   * @returns
+   */
+  async sdkLog(data) {
+    const strLog = Logger.formatStrLog(data);
+    const allData = [this.callKit.logger.sendSdkLogData, strLog].join(",");
+    const encoder = new TextEncoder();
+    const size = encoder.encode(allData).length;
+    if (size < 8192) {
+      this.callKit.logger.sendSdkLogData.push(strLog);
+    } else {
+      const logsToSend = this.callKit.logger.sendSdkLogData.slice();
+      this.callKit.logger.sendSdkLogData = [strLog];
+      return this.post(
+        {
+          url: "/agent/user/sdkLog",
+          method: "post",
+          data: {
+            content: logsToSend
+          }
+        },
+        {
+          useFormData: true
+        }
+      );
+    }
+  }
+  /**
+   *
+   * @param params agentId userStatus
+   * @description userStatus: Logout(1, "unregistered"), Free(2, "free"), Break(3, "nap"), Busy(4, "busy")
+   * @returns
+   */
+  async setUserStatus(params) {
+    return this.post({
+      url: "/agent/user/changeStatus",
+      method: "post",
+      data: params
+    });
+  }
+  async post(config, extra = {}) {
+    this.callKit.logger.debug(`Request ${config.url}:`, config.data);
+    const { userInfo, host } = this.callKit.config.getConfig();
+    const { sessionId } = userInfo;
+    config.url = `${host}${config.url}`;
+    config.headers = {
+      "Content-Type": "application/x-www-form-urlencoded",
+      ...config.headers
+    };
+    if (config.headers["Content-Type"] === "application/x-www-form-urlencoded" && extra.useFormData) {
+      const formData = new FormData();
+      const data2 = config.data || {};
+      for (const key in data2) {
+        if (Object.prototype.hasOwnProperty.call(data2, key)) {
+          formData.append(key, data2[key]);
+        }
+      }
+      config.data = formData;
+    } else {
+      config.data = new URLSearchParams(config.data).toString();
+    }
+    if (sessionId) {
+      config.headers.sessionId = sessionId;
+    }
+    const res = await axios_default(config).catch(() => {
+      this.callKit.config.reset();
+    });
+    if (!res) {
+      this.callKit.config.reset();
+      throw new Error("Network error");
+    } else {
+      this.callKit.logger.addLogData(LogDataEnum.ERROR, {
+        ...config,
+        status: "success",
+        endTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+        endTime: (/* @__PURE__ */ new Date()).toLocaleString()
+      });
+    }
+    const { code, data, message } = res;
+    if (code === "000000") {
+      return data;
+    }
+    this.callKit.logger.addLogData(LogDataEnum.AJAX, {
+      ...config,
+      status: "error",
+      endTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+      endTime: (/* @__PURE__ */ new Date()).toLocaleString()
+    });
+    if (code === "100013") {
+      this.callKit.config.reset();
+    }
+    throw new Error(message ?? "Request failed");
+  }
 };
 
 // package/call.ts
@@ -534,12 +793,6 @@ var Call = class {
     if (!this.callKit.config.check())
       return;
     this.callKit.logger.debug("callRefer");
-    const { toAgentId, workOrderId } = options;
-    const queryTrain = {
-      toAgentId,
-      workOrderId
-    };
-    this.callKit.socket.send(SocketSendEvent.AGENT_TRANSFER, queryTrain);
     this.callKit.connect.refer(referTo, options);
   }
   /**
@@ -586,7 +839,7 @@ var Config = class {
     this.callKit = callKit;
   }
   config = {
-    version: "1.0.2",
+    version: "1.0.24-beta.30",
     host: "",
     log: "debug",
     audioRef: void 0,
@@ -612,7 +865,8 @@ var Config = class {
       fsPort: "",
       iceInfo: [],
       iceGatheringTimeout: 0,
-      encryptionMethod: EncryptionMethod.INTERNAL
+      encryptionMethod: EncryptionMethod.INTERNAL,
+      logGather: LogGatherEnum.DISABLE
     },
     // EXECUTE setUserStatus
     isAutoUpdateUserStatus: true
@@ -644,7 +898,8 @@ var Config = class {
         fsPort: "",
         iceInfo: [],
         iceGatheringTimeout: this.config.userInfo.iceGatheringTimeout,
-        encryptionMethod: EncryptionMethod.INTERNAL
+        encryptionMethod: EncryptionMethod.INTERNAL,
+        logGather: LogGatherEnum.DISABLE
       };
       this.callKit.trigger(KitEvent.KIT_LOGIN_CHANGE, false);
     }
@@ -657,6 +912,7 @@ var Config = class {
     return true;
   };
   isLogin = () => this.validate();
+  isLogGatherEnable = () => this.config.userInfo.logGather === LogGatherEnum.ENABLE;
   check() {
     if (!this.isLogin()) {
       this.callKit.logger.error("User not logged in", {
@@ -668,78 +924,6 @@ var Config = class {
   }
 };
 
-// package/logger.ts
-function getLevel(level) {
-  return LoggerLevelMap[level];
-}
-var Logger = class {
-  prefix = "CallKit";
-  level = "debug";
-  callKit;
-  constructor(callKit, level) {
-    this.callKit = callKit;
-    this.level = level || "debug";
-  }
-  setLevel(level) {
-    this.level = level;
-  }
-  debug(msg, extra) {
-    if (getLevel(this.level) >= getLevel("debug")) {
-      this.output("blue")(msg, extra);
-    }
-  }
-  log(msg, extra) {
-    if (getLevel(this.level) >= getLevel("log")) {
-      this.output("green")(msg, extra);
-    }
-  }
-  warn(msg, extra) {
-    if (getLevel(this.level) >= getLevel("warn")) {
-      this.output("orange")(msg, extra);
-    }
-  }
-  error(msg, extra) {
-    const message = msg?.message ?? msg;
-    if (getLevel(this.level) >= getLevel("error")) {
-      this.output("red")(message, extra);
-    }
-    const { errCode, ...rest } = extra;
-    const errorCode = errCode ?? ErrorCode.UNKNOWN_ERROR;
-    this.callKit.trigger(KitEvent.KIT_ERROR, {
-      code: errorCode,
-      msg: message,
-      data: rest
-    });
-    this.callKit.reset();
-    const error = new Error(message);
-    error.name = "CallKitError";
-    error.code = errorCode;
-    error.data = rest;
-    throw error;
-  }
-  output(color) {
-    return (msg, extra = {}) => {
-      const now = /* @__PURE__ */ new Date();
-      if (Object.keys(extra).length > 0) {
-        console.log(
-          `%c[${this.prefix}] %c ${msg} %o %c ${now.toLocaleString()}`,
-          `color: ${color};`,
-          "color:block;",
-          extra,
-          "color:#999;"
-        );
-      } else {
-        console.log(
-          `%c[${this.prefix}] %c ${msg} %c ${now.toLocaleString()}`,
-          `color: ${color};`,
-          "color:block;",
-          "color:#999;"
-        );
-      }
-    };
-  }
-};
-
 // package/connect.ts
 var import_sip = require("sip.js");
 var DEFAULT_RECONNECT_CONFIG = {
@@ -763,7 +947,9 @@ var initUserMedia = () => {
       const getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia;
       if (!getUserMedia) {
         return Promise.reject(
-          new Error("Browser version is too low, please upgrade and try again.")
+          new Error(
+            "Unable to obtain device permissions. Please check your browser settings or device permissions."
+          )
         );
       }
       return new Promise((resolve, reject) => {
@@ -784,7 +970,7 @@ var Connect = class {
   registerer;
   lastOptionsUpdateTime = 0;
   observeOptionsHeartbeatHandler = null;
-  sipConnected = false;
+  // sipConnected = false;
   /**
    * Whether it's an outgoing call
    */
@@ -793,6 +979,7 @@ var Connect = class {
    * Whether it's an active hangup
    */
   isUnprompted = false;
+  isCurrentSessionInvited = false;
   reconnectConfig;
   /**
    * Whether registered
@@ -832,7 +1019,6 @@ var Connect = class {
     this.registerer = void 0;
     this.isOutgoing = false;
     this.isUnprompted = false;
-    this.sipConnected = false;
     this.clearObserveOptionsHeartbeatInterval();
     if (this.isHold) {
       this.setHoldStatus(false);
@@ -846,7 +1032,7 @@ var Connect = class {
     return audioRef;
   }
   async permission() {
-    this.callKit.logger.debug("permission");
+    this.callKit.logger.debug("ssion");
     initUserMedia();
     const _stream = await navigator.mediaDevices.getUserMedia({ audio: true });
     closeStream(_stream);
@@ -893,6 +1079,9 @@ var Connect = class {
   isInit() {
     return this.connectStatus === CallStatus.init;
   }
+  isExecuting() {
+    return this.callKit.user.getUserChangeStatusExecuting();
+  }
   clearObserveOptionsHeartbeatInterval() {
     if (this.observeOptionsHeartbeatHandler !== null) {
       clearInterval(this.observeOptionsHeartbeatHandler);
@@ -972,13 +1161,18 @@ var Connect = class {
       that.userAgent.transport.onDisconnect = (error) => {
         if (error) {
           that.callKit.logger.debug("connect onDisconnect");
-          if (that.isRegistered() && !(that.sipConnected || that.isRinging() || that.isCalling() || that.isHolding())) {
+          if (that.isRegistered() && !// that.sipConnected ||
+          (that.isRinging() || that.isCalling() || that.isHolding())) {
             that.reconnect();
           } else {
             that.callKit.logger.debug("SIP WebSocket closed with error", {
               event: ConnectEvent.SIP_CONNECT_ERROR,
               err: error
             });
+            that.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
+              event: ConnectEvent.SIP_CONNECT_ERROR,
+              err: error
+            });
             that.callKit.trigger(KitEvent.CONNECT_EVENT, {
               event: ConnectEvent.SIP_CONNECT_ERROR,
               err: error
@@ -994,7 +1188,7 @@ var Connect = class {
         }
       };
       that.clearObserveOptionsHeartbeatInterval();
-      setInterval(() => {
+      that.observeOptionsHeartbeatHandler = setInterval(() => {
         if (that.lastOptionsUpdateTime !== 0) {
           const now = (/* @__PURE__ */ new Date()).getTime();
           const diff = now - that.lastOptionsUpdateTime;
@@ -1009,6 +1203,11 @@ var Connect = class {
               lastOptionsUpdateTime: that.lastOptionsUpdateTime,
               now
             });
+            that.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
+              event: ConnectEvent.OPTIONS_HEARTBEAT_EXPIRED,
+              lastOptionsUpdateTime: that.lastOptionsUpdateTime,
+              now
+            });
             that.clearObserveOptionsHeartbeatInterval();
           }
         }
@@ -1020,38 +1219,118 @@ var Connect = class {
         if (request2.method === "OPTIONS") {
           that.lastOptionsUpdateTime = (/* @__PURE__ */ new Date()).getTime();
         }
+        that.callKit.logger.addLogData(LogDataEnum.SIP, request2);
         return originalReceiveRequest(request2);
       };
     };
     const registererOptions = {};
     this.registerer = new import_sip.Registerer(this.userAgent, registererOptions);
+    this.registerer.stateChange.addListener((state) => {
+      switch (state) {
+        case import_sip.RegistererState.Initial:
+          this.callKit.logger.debug("registerer stateChange Initial");
+          this.setRegister(false);
+          this.setConnectStatus(CallStatus.init);
+          this.callKit.user.setUserStatus(UserStatus.offline);
+          this.callKit.trigger(
+            KitEvent.SIP_REGISTERER_EVENT,
+            SipRegistererEvent.Initial
+          );
+          break;
+        case import_sip.RegistererState.Registered:
+          this.callKit.logger.debug("registerer stateChange Registered");
+          this.setRegister(true);
+          this.setConnectStatus(CallStatus.registered);
+          this.callKit.user.setUserStatus(UserStatus.online);
+          this.callKit.trigger(
+            KitEvent.SIP_REGISTERER_EVENT,
+            SipRegistererEvent.Registered
+          );
+          break;
+        case import_sip.RegistererState.Terminated:
+          this.callKit.logger.debug("registerer stateChange Terminated");
+          this.setRegister(false);
+          this.setConnectStatus(CallStatus.init);
+          this.callKit.user.setUserStatus(UserStatus.offline);
+          this.callKit.trigger(
+            KitEvent.SIP_REGISTERER_EVENT,
+            SipRegistererEvent.Terminated
+          );
+          break;
+        case import_sip.RegistererState.Unregistered:
+          this.callKit.logger.debug("registerer stateChange Unregistered");
+          this.setRegister(false);
+          this.setConnectStatus(CallStatus.init);
+          this.callKit.user.setUserStatus(UserStatus.offline);
+          this.callKit.trigger(
+            KitEvent.SIP_REGISTERER_EVENT,
+            SipRegistererEvent.Unregistered
+          );
+          break;
+        default:
+          break;
+      }
+    });
     this.userAgent.delegate = {
       onInvite: (invite) => {
         this.callKit.logger.debug("connect onInvite");
         this.currentSession = invite;
+        if (this.isOutgoing) {
+          this.isCurrentSessionInvited = false;
+        }
         this.currentSession.stateChange.addListener((state) => {
+          const isExecuting = this.isExecuting();
           switch (state) {
             case import_sip.SessionState.Establishing:
               this.callKit.logger.debug("connect Establishing");
+              this.setConnectStatus(CallStatus.ringing);
+              if (!isExecuting) {
+                this.callKit.user.setUserStatus(UserStatus.busy);
+                this.callKit.trigger(
+                  KitEvent.SIP_SESSION_EVENT,
+                  SipSessionEvent.Establishing
+                );
+              }
               break;
             case import_sip.SessionState.Established:
               this.callKit.logger.debug("connect Established");
-              if (this.connectStatus === CallStatus.registered) {
-                this.callKit.logger.warn("call is already hangup");
-                return;
+              this.callKit.connect.setConnectStatus(CallStatus.calling);
+              if (!isExecuting) {
+                this.callKit.trigger(
+                  KitEvent.SIP_SESSION_EVENT,
+                  SipSessionEvent.Established
+                );
+                setupRemoteMedia(this.currentSession);
               }
-              this.sipConnected = true;
-              setupRemoteMedia(this.currentSession);
               break;
             case import_sip.SessionState.Terminating:
               this.callKit.logger.debug("connect Terminating");
+              if (!isExecuting) {
+                this.callKit.trigger(
+                  KitEvent.SIP_SESSION_EVENT,
+                  SipSessionEvent.Terminating
+                );
+              }
               break;
             case import_sip.SessionState.Terminated:
               this.callKit.logger.debug("connect Terminated");
               if (!this.isUnprompted) {
                 this.callKit.callCenter.callEnd();
+              } else if (this.isCalling()) {
+                if (this.isCurrentSessionInvited) {
+                  this.currentSession.reject();
+                }
+                this.callKit.callCenter.callEnd(true, false);
               }
               this.isUnprompted = false;
+              if (!isExecuting) {
+                this.callKit.user.setUserStatus(UserStatus.catNap);
+                this.setConnectStatus(CallStatus.registered);
+                this.callKit.trigger(
+                  KitEvent.SIP_SESSION_EVENT,
+                  SipSessionEvent.Terminated
+                );
+              }
               break;
             default:
               break;
@@ -1065,17 +1344,37 @@ var Connect = class {
         };
         if (this.isOutgoing) {
           this.currentSession.accept(options);
+          this.callKit.trigger(KitEvent.KIT_OUTGOING_INVITE, {
+            getInviteData: () => {
+              const { request: request2 } = this.currentSession;
+              const headerNames = Object.keys(request2.headers);
+              const xHeaders = {};
+              headerNames.filter(
+                (name) => name.toLocaleLowerCase().startsWith("x-antaios")
+              ).forEach((name) => {
+                xHeaders[name.toLocaleLowerCase()] = request2.getHeader(name);
+              });
+              this.callKit.logger.debug("get invite data", xHeaders);
+              return xHeaders;
+            }
+          });
         } else {
+          const isExecuting = this.isExecuting();
+          const reject = () => {
+            this.currentSession.reject();
+            this.callKit.callCenter.callEnd(true, false);
+          };
+          if (isExecuting) {
+            reject();
+            return;
+          }
           this.callKit.trigger(KitEvent.KIT_INVITE, {
             accept: () => {
-              this.setConnectStatus(CallStatus.connecting);
+              this.isCurrentSessionInvited = true;
               this.callKit.trigger(KitEvent.CALL_CONNECTING, /* @__PURE__ */ new Date());
               this.currentSession.accept(options);
             },
-            reject: () => {
-              this.currentSession.reject();
-              this.callKit.callCenter.callEnd(true, false);
-            },
+            reject,
             getInviteData: () => {
               const { request: request2 } = this.currentSession;
               const headerNames = Object.keys(request2.headers);
@@ -1093,9 +1392,12 @@ var Connect = class {
       },
       onConnect: async () => {
         this.callKit.logger.debug("connect onConnect");
+        const version = `V${this.callKit.config.getConfig().version}`;
         await this.registerer.register().then(() => {
-          this.callKit.socket.send(SocketSendEvent.START);
-        }).catch((err) => {
+          this.callKit.socket.send(SocketSendEvent.START, {
+            version
+          });
+        }).catch(async (err) => {
           this.callKit.logger.error(err?.message, {
             errCode: ErrorCode.WEBRTC_REGISTER_ERROR
           });
@@ -1103,13 +1405,18 @@ var Connect = class {
       },
       onDisconnect: (error) => {
         this.callKit.logger.debug("connect onDisconnect");
-        if (this.isRegistered() && !(this.sipConnected || this.isRinging() || this.isCalling() || this.isHolding())) {
+        if (this.isRegistered() && !// this.sipConnected ||
+        (this.isRinging() || this.isCalling() || this.isHolding())) {
           this.reconnect();
         } else {
           this.callKit.trigger(KitEvent.CONNECT_EVENT, {
             event: ConnectEvent.SIP_CONNECT_ERROR,
             err: error
           });
+          this.callKit.logger.addLogData(LogDataEnum.ERROR, {
+            event: ConnectEvent.SIP_CONNECT_ERROR,
+            err: error
+          });
           this.callKit.user.sendHangUpReason({
             eventType: ConnectEvent.SIP_RECONNECT_ERROR,
             err: error
@@ -1161,6 +1468,11 @@ var Connect = class {
         return;
       reconnectTimer = setTimeout(async () => {
         try {
+          if (currentRetry === 0) {
+            this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+              event: ConnectEvent.SIP_RECONNECT_START
+            });
+          }
           currentRetry += 1;
           this.callKit.logger.debug(
             `Attempting to reconnect SIP... (Attempt ${currentRetry}/${this.reconnectConfig.maxAttempts})`
@@ -1203,9 +1515,7 @@ var Connect = class {
       this.callKit.logger.warn("No registerer to unregister.");
       return;
     }
-    await this.registerer.unregister({ all: true }).then(() => {
-      this.setConnectStatus(CallStatus.init);
-    }).catch((err) => {
+    await this.registerer.unregister({ all: true }).catch((err) => {
       this.callKit.logger.error(err, {
         errCode: ErrorCode.WEBRTC_CANCEL_REGISTER_ERROR
       });
@@ -1236,12 +1546,6 @@ var Connect = class {
    */
   setConnectStatus(status) {
     this.callKit.logger.debug(`connect setConnectStatus: ${status}`);
-    if (this.isRegistered() && status === CallStatus.init) {
-      this.setRegister(false);
-    }
-    if (!this.isRegistered() && status !== CallStatus.init) {
-      this.setRegister(true);
-    }
     this.connectStatus = status;
     this.callKit.trigger(KitEvent.KIT_CALL_STATUS_CHANGE, status);
   }
@@ -1259,13 +1563,14 @@ var Connect = class {
     this.isUnprompted = isUnprompted;
     try {
       if (isUnprompted) {
-        this.callKit.socket.send(SocketSendEvent.AGENT_HANGUP);
-        const shouldSendBye = this.sipConnected || this.isRinging() || this.isCalling() || this.isHolding();
+        const shouldSendBye = (
+          // this.sipConnected ||
+          this.isRinging() || this.isCalling() || this.isHolding()
+        );
         if (shouldSendBye) {
           await this.currentSession?.bye();
         }
       }
-      this.sipConnected = false;
       closeStream(this.mediaStream);
       const audioRef = this.getAduioReference();
       if (audioRef) {
@@ -1274,8 +1579,6 @@ var Connect = class {
       }
       if (isError) {
         this.setConnectStatus(CallStatus.init);
-      } else {
-        this.setConnectStatus(CallStatus.registered);
       }
       this.callKit.trigger(KitEvent.CALL_END, /* @__PURE__ */ new Date());
     } catch (err) {
@@ -1406,59 +1709,6 @@ var Connect = class {
   }
 };
 
-// package/monitor.ts
-var import_axios3 = __toESM(require("axios"));
-var defaultConfig = {
-  interval: 5e3,
-  apiEndpoint: "/livez"
-};
-var Monitor = class {
-  callKit;
-  interval = defaultConfig.interval;
-  apiEndpoint = defaultConfig.apiEndpoint;
-  monitorIntervalHandler = null;
-  constructor(callKit) {
-    this.callKit = callKit;
-    const { monitor } = this.callKit.config.getConfig();
-    this.interval = monitor?.interval ?? defaultConfig.interval;
-    this.apiEndpoint = monitor?.apiEndpoint ?? defaultConfig.apiEndpoint;
-    this.monitorIntervalHandler = null;
-  }
-  getEndPointPath = () => {
-    const config = this.callKit.config.getConfig();
-    const defaultPath = `${config.host}${this.apiEndpoint}`;
-    const endPointPath = config.monitor?.apiEndpoint ?? defaultPath;
-    return endPointPath;
-  };
-  measureRTT = async () => {
-    try {
-      const endPoint = this.getEndPointPath();
-      const startTime = performance.now();
-      await import_axios3.default.get(endPoint);
-      const endTime = performance.now();
-      const rtt = Math.round(endTime - startTime);
-      this.callKit.trigger(KitEvent.NETWORK_EVENT, {
-        event: NetWorkEvent.RTT_MEASURE_SUCCESS,
-        rtt
-      });
-    } catch (error) {
-      this.callKit.trigger(KitEvent.NETWORK_EVENT, {
-        event: NetWorkEvent.RTT_MEASURE_FAILED,
-        rtt: 0
-      });
-    }
-  };
-  stopRTTMonitoring() {
-    if (this.monitorIntervalHandler) {
-      clearInterval(this.monitorIntervalHandler);
-    }
-  }
-  startRTTMonitoring() {
-    this.stopRTTMonitoring();
-    this.monitorIntervalHandler = setInterval(this.measureRTT, this.interval);
-  }
-};
-
 // package/socket.ts
 var RECONNECT_CONFIG = {
   enabled: true,
@@ -1482,7 +1732,6 @@ var Socket = class {
   reconnectTimer;
   isReconnecting = false;
   reconnectAttempts = 0;
-  closing = false;
   constructor(callKit) {
     this.callKit = callKit;
     const { reconnect } = this.callKit.config.getConfig();
@@ -1496,15 +1745,13 @@ var Socket = class {
     this.callKit.logger.debug(`socket init: ${socket}`);
     this.connect(socket);
   }
-  close(code, reason) {
-    this.ws?.close(code, reason);
-  }
-  gracefulClose() {
-    this.closing = true;
-    this.callKit.trigger(KitEvent.CONNECT_EVENT, {
-      event: ConnectEvent.CONNECT_CLOSING
-    });
-    this.close(1e3, "normal");
+  // confirm from connect startConfirm
+  // startConfirm(status: boolean) {
+  //   this.callKit.logger.debug('register success');
+  //   this.satrtConfirm = status;
+  // }
+  setRecivedClose(status) {
+    this.recivedClose = status;
   }
   reconnect(ev) {
     this.callKit.logger.debug("socket reconnect", ev);
@@ -1514,12 +1761,21 @@ var Socket = class {
         "socket reconnect times",
         this.socketConfig.maxAttempts
       );
+      this.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
+        event: ConnectEvent.INCALL_RECONNECTING,
+        attempts: this.reconnectAttempts,
+        err: ev
+      });
       this.attemptReconnect();
     } else if (this.reconnectAttempts >= this.socketConfig.maxAttempts) {
       this.callKit.trigger(KitEvent.CONNECT_EVENT, {
         event: ConnectEvent.INCALL_RECONNECT_ERROR,
         err: ev
       });
+      this.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
+        event: ConnectEvent.INCALL_RECONNECT_ERROR,
+        err: ev
+      });
       this.reset();
       this.callKit.logger.error(
         "Reconnection failed, maximum retry attempts reached",
@@ -1538,6 +1794,10 @@ var Socket = class {
   }
   onOpen(ev) {
     this.callKit.logger.debug("socket onOpen", ev);
+    this.callKit.logger.addLogData(LogDataEnum.INCALL, {
+      callKitSocketFrom: "onOpen",
+      ev
+    });
     this.isConnected = true;
     this.lastPingTime = Date.now();
     this.checkPing();
@@ -1556,14 +1816,23 @@ var Socket = class {
   }
   onClose(ev) {
     this.callKit.logger.debug("socket onClose", ev);
-    if (ev.code === 4002) {
-      this.callKit.logger.debug("socket onClose", ev.reason);
-      return;
-    } else if ((ev.code !== 1e3 || !ev.wasClean) && this.callKit.connect.isRegistered()) {
+    this.callKit.logger.addLogData(LogDataEnum.INCALL, {
+      callKitSocketFrom: "onClose",
+      ev
+    });
+    if ((ev.code !== 1e3 || !ev.wasClean) && this.callKit.connect.isRegistered()) {
       this.callKit.trigger(KitEvent.CONNECT_EVENT, {
         event: ConnectEvent.INCALL_CONNECT_ERROR,
         err: ev
       });
+      this.callKit.logger.addLogData(LogDataEnum.ERROR, {
+        event: ConnectEvent.INCALL_CONNECT_ERROR,
+        err: ev
+      });
+      this.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
+        event: ConnectEvent.INCALL_CONNECT_ERROR,
+        err: ev
+      });
       this.reconnect(ev);
     } else {
       this.isConnected = false;
@@ -1574,10 +1843,6 @@ var Socket = class {
       }
       this.callKit.connect.hangup();
       this.reset();
-      this.closing = false;
-      this.callKit.trigger(KitEvent.CONNECT_EVENT, {
-        event: ConnectEvent.CONNECT_CLOSING_END
-      });
     }
   }
   onError(ev) {
@@ -1585,46 +1850,53 @@ var Socket = class {
       errCode: ErrorCode.SOCKET_CONNECT_ERROR,
       data: ev
     });
+    this.callKit.logger.addLogData(LogDataEnum.INCALL, {
+      callKitSocketFrom: "onError",
+      ev
+    });
     if (this.isReconnecting) {
       this.attemptReconnect();
     }
   }
+  confirmAck(data) {
+    const { ack, messageId } = data;
+    if (ack) {
+      this.send(SocketSendEvent.ACK, {
+        messageId
+        // sessionId
+      });
+    }
+  }
   onMessage(ev) {
     const data = JSON.parse(ev.data);
     this.callKit.logger.debug("socket onMessage", data);
+    this.callKit.logger.addLogData(LogDataEnum.INCALL, {
+      callKitSocketFrom: "onMessage",
+      ev
+    });
+    this.confirmAck(data);
     if (data.event === SocketReceiveEvent.PONG) {
       this.lastPingTime = Date.now();
       return;
     }
     if (data.event === SocketReceiveEvent.START_CONFIRM) {
-      this.callKit.logger.debug("register success");
+      this.callKit.logger.debug("start confirm success");
       this.satrtConfirm = true;
-      this.callKit.connect.setConnectStatus(CallStatus.registered);
     }
     if (data.event === SocketReceiveEvent.CALL_SUCCESS) {
       this.recivedClose = false;
-      this.callKit.logger.debug("callStart");
-      this.callKit.user.setUserStatus(UserStatus.busy);
     }
     if (data.event === SocketReceiveEvent.CALL_FAILED) {
       this.callKit.logger.debug(data.msg, {
         errCode: ErrorCode.SOCKET_CALL_ERROR
       });
-      this.callKit.user.setUserStatus(UserStatus.online);
     }
     if (data.event === SocketReceiveEvent.CUSTOMER_RINGING) {
-      this.callKit.logger.debug(data.msg);
-      if (this.callKit.connect.isConnecting()) {
-        this.callKit.trigger(KitEvent.CALL_RINGING, /* @__PURE__ */ new Date());
-        this.callKit.connect.setConnectStatus(CallStatus.ringing);
-      }
+      this.callKit.trigger(KitEvent.CALL_RINGING, /* @__PURE__ */ new Date());
     }
     if (data.event === SocketReceiveEvent.CUSTOMER_PICK_UP) {
       this.callKit.logger.debug(data.msg);
-      if (this.callKit.connect.isRinging()) {
-        this.callKit.connect.setConnectStatus(CallStatus.calling);
-        this.callKit.trigger(KitEvent.CALL_PICK_UP, /* @__PURE__ */ new Date());
-      }
+      this.callKit.trigger(KitEvent.CALL_PICK_UP, /* @__PURE__ */ new Date());
     }
     if (data.event === SocketReceiveEvent.AGENT_PICK_UP) {
       this.callKit.logger.debug(data.msg);
@@ -1633,12 +1905,10 @@ var Socket = class {
     if (data.event === SocketReceiveEvent.CUSTOMER_HANG_UP) {
       this.callKit.logger.debug(data.msg);
       this.callKit.trigger(KitEvent.CALL_HANG_UP, /* @__PURE__ */ new Date());
-      this.callKit.user.setUserStatus(UserStatus.catNap);
     }
     if (data.event === SocketReceiveEvent.CUSTOMER_NO_ANSWER) {
       this.callKit.logger.debug(data.msg);
       this.callKit.trigger(KitEvent.CALL_NO_ANSWER);
-      this.callKit.user.setUserStatus(UserStatus.catNap);
     }
     if (data.event === SocketReceiveEvent.CALL_CDR) {
       this.callKit.logger.debug(data.msg);
@@ -1646,7 +1916,7 @@ var Socket = class {
     }
     if (data.event === SocketReceiveEvent.STOP_CONFIRM) {
       this.callKit.logger.debug(data.msg);
-      this.recivedClose = true;
+      this.setRecivedClose(true);
     }
     if (data.event === SocketReceiveEvent.CLOSE) {
       const { userInfo } = this.callKit.config.getConfig();
@@ -1656,19 +1926,21 @@ var Socket = class {
       });
     }
     if (data.event === SocketReceiveEvent.ERROR) {
-      this.callKit.logger.error(data.msg, {
+      this.callKit.unregister();
+      this.callKit.logger.debug(data.msg, {
         errCode: ErrorCode.SOKET_SERVER_ERROR,
         data
       });
-      this.callKit.user.setUserStatus(UserStatus.catNap);
     }
     if (data.event === SocketReceiveEvent.AGENT_NO_ANSWER) {
-      this.callKit.user.setUserStatus(UserStatus.catNap);
     }
     this.callKit.trigger(KitEvent.SERVER_SOCKET_EVENT, data);
   }
   send(event, message) {
     if (!this.isConnected) {
+      this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+        event: ConnectEvent.INCALL_NOT_CONNECTED
+      });
       this.callKit.logger.error("socket not connected", {
         errCode: ErrorCode.SOCKET_CONNECT_ERROR
       });
@@ -1711,6 +1983,9 @@ var Socket = class {
   }
   async sendMessage(event, message) {
     if (!this.isConnected) {
+      this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+        event: ConnectEvent.INCALL_NOT_CONNECTED
+      });
       this.callKit.logger.error("socket not connected", {
         errCode: ErrorCode.SOCKET_CONNECT_ERROR
       });
@@ -1785,11 +2060,16 @@ var Socket = class {
       }
       this.recivedClose = false;
       this.callKit.logger.debug("socket destroy");
-      this.ws.close(4002, "sdk reset");
+      this.ws.close();
       this.isConnected = false;
     }
   }
   attemptReconnect() {
+    if (this.reconnectAttempts === 0) {
+      this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+        event: ConnectEvent.INCALL_RECONNECT_START
+      });
+    }
     if (this.isReconnecting && this.reconnectAttempts >= this.socketConfig.maxAttempts) {
       this.callKit.trigger(KitEvent.CONNECT_EVENT, {
         event: ConnectEvent.INCALL_RECONNECT_ERROR
@@ -1824,8 +2104,102 @@ var User = class {
   callKit;
   userStatus;
   // logout(1, "unregistered"), idle(2, "free"), break(3, "nap"), busy(4, "busy")
+  userChangeStatusExecuting;
   constructor(callKit) {
     this.callKit = callKit;
+    this.userChangeStatusExecuting = false;
+  }
+  setUserChangeStatusExecuting(state) {
+    this.userChangeStatusExecuting = state;
+  }
+  getUserChangeStatusExecuting() {
+    return this.userChangeStatusExecuting;
+  }
+  async login(params) {
+    const postData = {
+      userName: params.userName,
+      password: params.password
+    };
+    const logData = {
+      postData,
+      url: "/auth/agentUser/login",
+      status: "send",
+      startTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+      startTime: (/* @__PURE__ */ new Date()).toLocaleString()
+    };
+    this.callKit.logger.addLogData(LogDataEnum.AJAX, logData);
+    this.setUserChangeStatusExecuting(true);
+    return this.callKit.api.login(params).then((user) => {
+      this.setUserChangeStatusExecuting(false);
+      this.callKit.logger.addLogData(LogDataEnum.AJAX, {
+        ...logData,
+        status: "success",
+        endTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+        endTime: (/* @__PURE__ */ new Date()).toLocaleString()
+      });
+      this.callKit.trigger(KitEvent.USER_STATUS_CHANGE_STEP, {
+        event: UserStatusChangeStepEnum.UserStatusChangeLoginEnd
+      });
+      return user;
+    }).catch((err) => {
+      this.setUserChangeStatusExecuting(false);
+      this.callKit.logger.addLogData(LogDataEnum.AJAX, {
+        ...logData,
+        status: "error",
+        endTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+        endTime: (/* @__PURE__ */ new Date()).toLocaleString()
+      });
+      this.callKit.trigger(KitEvent.USER_STATUS_CHANGE_STEP, {
+        event: UserStatusChangeStepEnum.UserStatusChangeLoginError
+      });
+      this.callKit.logger.error(err, {
+        errCode: ErrorCode.API_USER_LOGIN_ERROR
+      });
+    });
+  }
+  async loginOut(params) {
+    const postData = {
+      sessionId: params.sessionId
+    };
+    const logData = {
+      postData,
+      url: "/auth/agentUser/loginOut",
+      status: "send",
+      startTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+      startTime: (/* @__PURE__ */ new Date()).toLocaleString()
+    };
+    this.callKit.logger.addLogData(LogDataEnum.AJAX, logData);
+    this.callKit.trigger(KitEvent.USER_STATUS_CHANGE_STEP, {
+      event: UserStatusChangeStepEnum.UserStatusChangeLoginOutStart
+    });
+    this.setUserChangeStatusExecuting(true);
+    return this.callKit.api.loginOut(postData).then((res) => {
+      this.setUserChangeStatusExecuting(false);
+      this.callKit.logger.addLogData(LogDataEnum.AJAX, {
+        ...logData,
+        status: "success",
+        endTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+        endTime: (/* @__PURE__ */ new Date()).toLocaleString()
+      });
+      this.callKit.trigger(KitEvent.USER_STATUS_CHANGE_STEP, {
+        event: UserStatusChangeStepEnum.UserStatusChangeLoginOutEnd
+      });
+      return res;
+    }).catch((err) => {
+      this.setUserChangeStatusExecuting(false);
+      this.callKit.logger.addLogData(LogDataEnum.AJAX, {
+        ...logData,
+        status: "error",
+        endTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+        endTime: (/* @__PURE__ */ new Date()).toLocaleString()
+      });
+      this.callKit.trigger(KitEvent.USER_STATUS_CHANGE_STEP, {
+        event: UserStatusChangeStepEnum.UserStatusChangeLoginOutError
+      });
+      this.callKit.logger.error(err, {
+        errCode: ErrorCode.API_USER_LOGOUT_ERROR
+      });
+    });
   }
   /**
    *
@@ -1842,24 +2216,70 @@ var User = class {
    * @param status
    */
   async updateUserStatus(status) {
-    const { agentId } = this.callKit.config.getConfig().userInfo;
-    if (!this.callKit.config.isLogin()) {
-      this.userStatus = UserStatus.offline;
-      this.callKit.trigger(KitEvent.KIT_USER_STATUS_CHANGE, UserStatus.offline);
+    if (this.userChangeStatusExecuting)
       return;
-    }
-    await this.callKit.api.setUserStatus({
+    const { agentId } = this.callKit.config.getConfig().userInfo;
+    this.setUserChangeStatusExecuting(true);
+    const postData = {
       agentId,
       userStatus: status
-    }).then(() => {
+    };
+    const logData = {
+      postData,
+      url: "/agent/user/changeStatus",
+      status: "send",
+      startTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+      startTime: (/* @__PURE__ */ new Date()).toLocaleString()
+    };
+    this.callKit.logger.addLogData(LogDataEnum.AJAX, logData);
+    this.callKit.trigger(KitEvent.USER_STATUS_CHANGE_STEP, {
+      event: UserStatusChangeStepEnum.UserStatusChangeStart
+    });
+    await this.callKit.api.setUserStatus(postData).then(() => {
+      this.setUserChangeStatusExecuting(false);
       this.userStatus = status;
+      this.callKit.trigger(KitEvent.USER_STATUS_CHANGE_STEP, {
+        event: UserStatusChangeStepEnum.UserStatusChangeEnd
+      });
       this.callKit.trigger(KitEvent.KIT_USER_STATUS_CHANGE, status);
+      this.callKit.logger.addLogData(LogDataEnum.AJAX, {
+        ...logData,
+        status: "success",
+        endTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+        endTime: (/* @__PURE__ */ new Date()).toLocaleString()
+      });
     }).catch((err) => {
+      this.setUserChangeStatusExecuting(false);
+      this.callKit.logger.addLogData(LogDataEnum.AJAX, {
+        ...logData,
+        status: "error",
+        endTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+        endTime: (/* @__PURE__ */ new Date()).toLocaleString()
+      });
+      this.callKit.trigger(KitEvent.USER_STATUS_CHANGE_STEP, {
+        event: UserStatusChangeStepEnum.UserStatusChangeError
+      });
+      this.setUserChangeStatusExecuting(false);
+      if (this.callKit.connect.isRegistered()) {
+        this.callKit.unregister();
+      }
+      this.callKit.trigger(
+        KitEvent.KIT_USER_STATUS_CHANGE,
+        UserStatus.offline
+      );
       this.callKit.logger.error(err, {
         errCode: ErrorCode.API_USER_STATUS_UPDATE_ERROR
       });
     });
   }
+  /**
+   * @description sdkLog
+   * @param params
+   * @returns
+   */
+  async sendSdkLog(data) {
+    return this.callKit.api.sdkLog(data);
+  }
   async sendHangUpReason(data) {
     try {
       const sendData = data || {};
@@ -1879,7 +2299,6 @@ var CallKit = class {
   connect;
   socket;
   user;
-  monitor;
   listener = [];
   constructor(options) {
     this.config = new Config(this);
@@ -1897,8 +2316,6 @@ var CallKit = class {
     );
     this.config.setConfig("reconnect", options.reconnect);
     this.logger = new Logger(this, options.log);
-    this.config.setConfig("monitor", options.monitor);
-    this.monitor = new Monitor(this);
     this.logger.debug("callKit init", options);
     this.api = new Api(this);
     this.connect = new Connect(this);
@@ -1932,11 +2349,9 @@ var CallKit = class {
       encryptionMethod,
       encryptionPassword
     });
-    const user = await this.api.login({
+    const user = await this.user.login({
       userName: username,
       password: encryptionPassword
-    }).catch((err) => {
-      this.logger.error(err, { errCode: ErrorCode.API_USER_LOGIN_ERROR });
     });
     if (user) {
       this.config.setConfig("userInfo", {
@@ -1953,6 +2368,7 @@ var CallKit = class {
         fsPort: user.fsPort,
         iceInfo: user.iceInfo,
         iceGatheringTimeout: user.iceGatheringTimeout,
+        logGather: user.logGather,
         // encryptionType is in extra
         ...extra
       });
@@ -1968,12 +2384,7 @@ var CallKit = class {
     await this.user.setUserStatus(UserStatus.offline);
     if (this.config.isLogin()) {
       const { sessionId } = this.config.getConfig().userInfo;
-      this.unregister();
-      this.stop();
-      this.socket.gracefulClose();
-      this.api.loginOut({ sessionId }).catch((err) => {
-        this.logger.error(err, { errCode: ErrorCode.API_USER_LOGOUT_ERROR });
-      });
+      this.user.loginOut({ sessionId });
     }
     await this.hangup();
     this.socket.reset(false);
@@ -2016,14 +2427,12 @@ var CallKit = class {
       return;
     this.logger.debug("register");
     this.connect.register();
-    await this.user.setUserStatus(UserStatus.online);
   }
   async unregister() {
     if (!this.config.check())
       return;
     this.logger.debug("unregister");
     this.connect.unregister();
-    await this.user.setUserStatus(UserStatus.offline);
   }
   async stop() {
     await this.connect.stop();
@@ -2037,7 +2446,6 @@ var CallKit = class {
       return;
     }
     await this.callCenter.callEnd(true);
-    this.user.setUserStatus(UserStatus.catNap);
   }
   hold() {
     if (!this.config.check())
@@ -2078,12 +2486,6 @@ var CallKit = class {
       await this.user.setUserStatus(UserStatus.offline);
     }
   }
-  startRTTMonitoring() {
-    this.monitor.startRTTMonitoring();
-  }
-  stopRTTMonitoring() {
-    this.monitor.stopRTTMonitoring();
-  }
   on(event, callback) {
     this.logger.debug(`on ${event}`);
     this.listener.push({