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

package/dist/index.js

@@ -67,42 +67,98 @@ instance.interceptors.response.use(
 var request = (config) => instance.request(config);
 var axios_default = request;
 
-// package/const.ts
-var UserStatus = {
-  /**
-   * Offline
-   */
-  offline: 1,
-  /**
-   * Online & Idle
-   */
-  online: 2,
-  /**
-   * Nap
-   */
-  catNap: 3,
-  /**
-   * Busy
-   */
-  busy: 4,
-  /**
-   * Training
-   */
-  training: 5,
+// 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
+    });
+  }
+  async trackLogs(log) {
+    return this.post(
+      { url: "/agent/user/sdkLog", method: "post", data: { content: [log] } },
+      {
+        useFormData: true
+      }
+    );
+  }
   /**
-   * Processing
+   *
+   * @param params agentId status
+   * @returns
    */
-  processing: 6
+  async updateUserStatus(params) {
+    return this.post({
+      url: "/agent/user/changeStatus",
+      method: "post",
+      data: params
+    });
+  }
+  async post(config, extra = {}) {
+    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");
+    }
+    const { code, data, message } = res;
+    if (code === "000000") {
+      return data;
+    }
+    if (code === "100013") {
+      this.callKit.config.reset();
+    }
+    throw new Error(message ?? "Request failed");
+  }
 };
+
+// package/const.ts
 var CallStatus = {
   /**
    * Initial state/Hang up
    */
   init: 0,
-  /**
-   * Registered
-   */
-  registered: 1,
+  // /**
+  //  * @deprecated Deprecated
+  //  * Registered
+  //  */
+  // registered: 1,
   /**
    * Connecting
    */
@@ -121,6 +177,10 @@ var CallStatus = {
   calling: 5
 };
 var KitEvent = {
+  /**
+   * Log
+   */
+  KIT_LOG: "log",
   /**
    * User status change
    */
@@ -203,8 +263,7 @@ var KitEvent = {
   USER_STATUS_CHANGE: "userStatusChange",
   CONNECT_EVENT: "CONNECT_EVENT",
   SIP_REGISTERER_EVENT: "sipRegistererEvent",
-  SIP_SESSION_EVENT: "sipSessionEvent",
-  USER_STATUS_CHANGE_STEP: "userStatusChangeStep"
+  SIP_SESSION_EVENT: "sipSessionEvent"
 };
 var ErrorCode = {
   /**
@@ -293,8 +352,8 @@ var ErrorCode = {
   SOCKET_RECONNECT_FAILED: 3000005
 };
 var LoggerLevelMap = {
-  debug: 9,
-  log: 4,
+  info: 9,
+  success: 4,
   warn: 3,
   error: 2,
   silent: 1
@@ -340,8 +399,7 @@ var SocketSendEvent = {
    * AGENT_TRANSFER
    */
   HANG_UP_REASON: "HANG_UP_REASON",
-  ACK: "ACK",
-  SDK_LOG: "SDK_LOG"
+  ACK: "ACK"
 };
 var SocketReceiveEvent = {
   /**
@@ -405,10 +463,6 @@ var EncryptionMethod = {
   NONE: "NONE",
   INTERNAL: "INTERNAL"
 };
-var LogGatherEnum = {
-  ENABLE: 1,
-  DISABLE: 2
-};
 var constrainsDefault = {
   audio: {
     autoGainControl: true,
@@ -419,338 +473,10 @@ var constrainsDefault = {
   },
   video: false
 };
-var isAutoUpdateUserStatusDefault = true;
 var CallSourceType = {
   phoneNum: 1,
   workOrderId: 2
 };
-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"
-};
-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"
-};
-
-// 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
 var Call = class {
@@ -761,9 +487,19 @@ var Call = class {
   async callStart() {
     if (!this.callKit.config.check())
       return;
-    this.callKit.logger.debug("callStart");
+    this.callKit.logger.info("callStart", {
+      caller: "Call.callStart",
+      content: {
+        startConfirm: this.callKit.socket.satrtConfirm
+      }
+    });
     if (!this.callKit.socket.satrtConfirm) {
-      this.callKit.logger.warn("server not confirm start");
+      this.callKit.logger.warn("server not confirm start", {
+        caller: "Call.callStart",
+        content: {
+          startConfirm: this.callKit.socket.satrtConfirm
+        }
+      });
       return;
     }
     this.callKit.connect.call(async (user) => {
@@ -792,7 +528,13 @@ var Call = class {
   async callRefer(referTo, options) {
     if (!this.callKit.config.check())
       return;
-    this.callKit.logger.debug("callRefer");
+    this.callKit.logger.info("callRefer", {
+      caller: "Call.callRefer",
+      content: {
+        referTo,
+        options
+      }
+    });
     this.callKit.connect.refer(referTo, options);
   }
   /**
@@ -802,7 +544,7 @@ var Call = class {
    * @returns
    */
   async callEnd(isUnprompted = false, isError = false) {
-    if (this.callKit.connect.connectStatus === CallStatus.init || this.callKit.connect.connectStatus === CallStatus.registered)
+    if (this.callKit.connect.connectStatus === CallStatus.init)
       return;
     if (!this.callKit.config.check())
       return;
@@ -812,10 +554,14 @@ var Call = class {
     if (!this.callKit.config.check())
       return;
     if (!this.callKit.connect.isCalling()) {
-      this.callKit.logger.warn("Current state cannot be held");
+      this.callKit.logger.warn("Current state cannot be held", {
+        caller: "Call.callHold",
+        content: {
+          isCalling: this.callKit.connect.isCalling()
+        }
+      });
       return;
     }
-    this.callKit.connect.hold();
     this.callKit.socket.send(SocketSendEvent.HOLD);
     this.callKit.connect.setConnectStatus(CallStatus.holding);
   }
@@ -823,10 +569,14 @@ var Call = class {
     if (!this.callKit.config.check())
       return;
     if (!this.callKit.connect.isHolding()) {
-      this.callKit.logger.warn("Current state cannot unhold");
+      this.callKit.logger.warn("Current state cannot unhold", {
+        caller: "Call.callUnhold",
+        content: {
+          isHolding: this.callKit.connect.isHolding()
+        }
+      });
       return;
     }
-    this.callKit.connect.unhold();
     this.callKit.socket.send(SocketSendEvent.UNHOLD);
     this.callKit.connect.setConnectStatus(CallStatus.calling);
   }
@@ -839,9 +589,10 @@ var Config = class {
     this.callKit = callKit;
   }
   config = {
-    version: "1.0.24-beta.30",
+    version: "1.0.27",
     host: "",
-    log: "debug",
+    log: "info",
+    trackLogs: false,
     audioRef: void 0,
     constrains: constrainsDefault,
     socket: "",
@@ -865,11 +616,8 @@ var Config = class {
       fsPort: "",
       iceInfo: [],
       iceGatheringTimeout: 0,
-      encryptionMethod: EncryptionMethod.INTERNAL,
-      logGather: LogGatherEnum.DISABLE
-    },
-    // EXECUTE setUserStatus
-    isAutoUpdateUserStatus: true
+      encryptionMethod: EncryptionMethod.INTERNAL
+    }
   };
   getConfig = () => this.config;
   setConfig = async (key, value) => {
@@ -877,7 +625,13 @@ var Config = class {
   };
   setUserInfo = async (key, value) => {
     this.config.userInfo[key] = value;
-    this.callKit.logger.debug(`setUserInfo: key: ${key}, value: ${value}`);
+    this.callKit.logger.info("setUserInfo", {
+      caller: "Config.setUserInfo",
+      content: {
+        key,
+        value
+      }
+    });
   };
   reset = () => {
     if (this.isLogin()) {
@@ -898,8 +652,7 @@ var Config = class {
         fsPort: "",
         iceInfo: [],
         iceGatheringTimeout: this.config.userInfo.iceGatheringTimeout,
-        encryptionMethod: EncryptionMethod.INTERNAL,
-        logGather: LogGatherEnum.DISABLE
+        encryptionMethod: EncryptionMethod.INTERNAL
       };
       this.callKit.trigger(KitEvent.KIT_LOGIN_CHANGE, false);
     }
@@ -912,11 +665,13 @@ 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", {
-        errCode: ErrorCode.USER_NOT_LOGIN
+      this.callKit.logger.warn("User not logged in", {
+        caller: "Config.check",
+        content: {
+          errCode: ErrorCode.USER_NOT_LOGIN
+        }
       });
       return false;
     }
@@ -924,12 +679,149 @@ var Config = class {
   }
 };
 
-// package/connect.ts
-var import_sip = require("sip.js");
-var DEFAULT_RECONNECT_CONFIG = {
+// package/logger.ts
+var import_json_stringify_safe = __toESM(require("json-stringify-safe"));
+function getLevel(level) {
+  return LoggerLevelMap[level];
+}
+function transformLog(log) {
+  const { timestamp, level, type = "OTHER", message, caller, content } = log;
+  const logLevel = String(level).toUpperCase();
+  return `${timestamp} [${logLevel}] [${type}] [${caller ?? "unknown"}]  [${message}] ${(0, import_json_stringify_safe.default)(content)}`.trim();
+}
+var MAX_SIZE = 8192;
+var FLUSH_INTERVAL = 5e3;
+function getByteSize(str) {
+  return new Blob([str]).size;
+}
+var Logger = class {
+  prefix = "CallKit";
+  level = "info";
+  pendingTrackLogs = [];
+  trackLogsTimer = null;
+  callKit;
+  constructor(callKit, level) {
+    this.callKit = callKit;
+    this.level = level || "info";
+    this.startTrackLogsTimer();
+  }
+  startTrackLogsTimer() {
+    if (this.trackLogsTimer) {
+      return;
+    }
+    this.trackLogsTimer = setInterval(() => {
+      this.flushTrackLogs();
+    }, FLUSH_INTERVAL);
+  }
+  flushTrackLogs() {
+    if (this.pendingTrackLogs.length === 0) {
+      return;
+    }
+    const { trackLogs } = this.callKit.config.getConfig();
+    if (trackLogs) {
+      try {
+        const chunks = [];
+        let currentChunk = [];
+        let currentSize = 0;
+        for (const log of this.pendingTrackLogs) {
+          const logSize = getByteSize(log);
+          const separator = currentChunk.length > 0 ? "\n" : "";
+          const separatorSize = getByteSize(separator);
+          if (currentSize + logSize + separatorSize > MAX_SIZE && currentChunk.length > 0) {
+            chunks.push(currentChunk.join("\n"));
+            currentChunk = [log];
+            currentSize = logSize;
+          } else {
+            currentChunk.push(log);
+            currentSize += logSize + separatorSize;
+          }
+        }
+        if (currentChunk.length > 0) {
+          chunks.push(currentChunk.join("\n"));
+        }
+        for (const chunk of chunks) {
+          this.callKit.api.trackLogs(chunk);
+        }
+        this.pendingTrackLogs = [];
+      } catch (error) {
+        console.error(error);
+      }
+    }
+  }
+  destroy() {
+    if (this.trackLogsTimer) {
+      clearInterval(this.trackLogsTimer);
+      this.trackLogsTimer = null;
+    }
+    this.flushTrackLogs();
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  info(msg, extra) {
+    const logString = this.catchLog(msg, extra, "info");
+    if (getLevel(this.level) >= getLevel("info")) {
+      console.log(`%c${logString}`, `color: gray;`);
+    }
+  }
+  success(msg, extra) {
+    const logString = this.catchLog(msg, extra, "success");
+    if (getLevel(this.level) >= getLevel("success")) {
+      console.log(`%c${logString}`, `color: green;`);
+    }
+  }
+  warn(msg, extra) {
+    const logString = this.catchLog(msg, extra, "warn");
+    if (getLevel(this.level) >= getLevel("warn")) {
+      console.log(`%c${logString}`, `color: orange;`);
+    }
+  }
+  error(msg, extra) {
+    const errorMsg = msg instanceof Error ? msg.message : msg;
+    const logString = this.catchLog(errorMsg, extra, "error");
+    if (getLevel(this.level) >= getLevel("error")) {
+      console.log(`%c${logString}`, `color: red;`);
+    }
+    const { errCode, ...rest } = extra?.content ?? {};
+    const errorCode = errCode ?? ErrorCode.UNKNOWN_ERROR;
+    this.callKit.trigger(KitEvent.KIT_ERROR, {
+      code: errorCode,
+      msg: errorMsg,
+      data: rest
+    });
+    const error = new Error(errorMsg);
+    error.name = "CallKitError";
+    error.code = errorCode;
+    error.data = rest;
+    throw error;
+  }
+  catchLog(msg, extra, level) {
+    const now = /* @__PURE__ */ new Date();
+    const log = {
+      timestamp: now.toLocaleString().replace("T", " ").replace(".000Z", ""),
+      level,
+      message: msg,
+      caller: extra?.caller,
+      type: extra?.type,
+      content: extra?.content ?? {}
+    };
+    const logString = transformLog(log);
+    const { trackLogs } = this.callKit.config.getConfig();
+    if (trackLogs) {
+      this.pendingTrackLogs.push(logString);
+    }
+    this.callKit.trigger(KitEvent.KIT_LOG, logString);
+    return logString;
+  }
+};
+
+// package/connect.ts
+var import_sip = require("sip.js");
+var DEFAULT_RECONNECT_CONFIG = {
   maxAttempts: 3,
   delay: 500
 };
+var MAX_HEARTBEAT_COUNT = 6;
 function convertObjectStringToJSON(input) {
   const corrected = input.replace(/(\w+):\s*'(.*?)'/g, '"$1": "$2"').replace(/'/g, '"');
   return corrected;
@@ -968,7 +860,12 @@ var Connect = class {
   mediaStream;
   userAgent;
   registerer;
-  lastOptionsUpdateTime = 0;
+  // current call id for invite data
+  currentCallId;
+  /**
+   * Whether it's a re-connected
+   */
+  isReConnected = false;
   observeOptionsHeartbeatHandler = null;
   // sipConnected = false;
   /**
@@ -981,23 +878,14 @@ var Connect = class {
   isUnprompted = false;
   isCurrentSessionInvited = false;
   reconnectConfig;
-  /**
-   * Whether registered
-   * @param
-   * @deprecated Deprecated, please use isRegistered method
-   */
-  get isRegister() {
-    return this.isRegistered();
-  }
-  /**
-   * Call hold
-   * @param isHold
-   */
-  isHold = false;
   /**
    * Whether muted
    */
   isMute = false;
+  /**
+   * Whether registered
+   */
+  isRegistered = false;
   constructor(callKit) {
     this.callKit = callKit;
     const { reconnect = {} } = this.callKit.config.getConfig();
@@ -1007,10 +895,13 @@ var Connect = class {
     };
   }
   reset() {
+    if (this.isHolding()) {
+      this.setHoldStatus(false);
+    }
     if (this.connectStatus !== CallStatus.init) {
       this.setConnectStatus(CallStatus.init);
     }
-    if (this.isRegistered()) {
+    if (this.isRegistered) {
       this.unregister();
     }
     this.currentSession = void 0;
@@ -1019,10 +910,23 @@ var Connect = class {
     this.registerer = void 0;
     this.isOutgoing = false;
     this.isUnprompted = false;
-    this.clearObserveOptionsHeartbeatInterval();
-    if (this.isHold) {
-      this.setHoldStatus(false);
+    if (this.mediaStream) {
+      try {
+        closeStream(this.mediaStream);
+        const audioRef = this.getAduioReference();
+        if (audioRef) {
+          audioRef.pause();
+          audioRef.srcObject = null;
+        }
+      } catch (error) {
+        this.callKit.logger.error(error, {
+          caller: "Connect.reset",
+          content: {}
+        });
+      }
     }
+    this.setConnectStatus(CallStatus.init);
+    this.clearObserveOptionsHeartbeatInterval();
   }
   getAduioReference() {
     const { audioRef } = this.callKit.config.getConfig();
@@ -1032,20 +936,16 @@ var Connect = class {
     return audioRef;
   }
   async permission() {
-    this.callKit.logger.debug("ssion");
+    this.callKit.logger.info("permission", {
+      caller: "Connect.permission",
+      content: {
+        permission: true
+      }
+    });
     initUserMedia();
     const _stream = await navigator.mediaDevices.getUserMedia({ audio: true });
     closeStream(_stream);
   }
-  isRegistered() {
-    return [
-      CallStatus.registered,
-      CallStatus.connecting,
-      CallStatus.ringing,
-      CallStatus.calling,
-      CallStatus.holding
-    ].includes(this.connectStatus);
-  }
   /**
    * Making connection
    * @returns
@@ -1079,33 +979,59 @@ var Connect = class {
   isInit() {
     return this.connectStatus === CallStatus.init;
   }
-  isExecuting() {
-    return this.callKit.user.getUserChangeStatusExecuting();
-  }
   clearObserveOptionsHeartbeatInterval() {
     if (this.observeOptionsHeartbeatHandler !== null) {
       clearInterval(this.observeOptionsHeartbeatHandler);
       this.observeOptionsHeartbeatHandler = null;
     }
-    this.lastOptionsUpdateTime = 0;
+  }
+  heartbeatFlag = MAX_HEARTBEAT_COUNT;
+  startHeartbeat() {
+    this.heartbeatFlag = MAX_HEARTBEAT_COUNT;
+    setTimeout(() => {
+      this.heartbeatFlag -= 1;
+      if (this.heartbeatFlag <= 0) {
+        this.heartbeatFlag = MAX_HEARTBEAT_COUNT;
+        this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+          event: "OPTIONS_HEARTBEAT_EXPIRED"
+        });
+      }
+    }, 1e3);
   }
   async register() {
     if (this.connectStatus !== CallStatus.init) {
-      if (this.connectStatus === CallStatus.registered) {
-        this.callKit.logger.warn("connectStatus is registered");
+      if (this.isRegistered) {
+        this.callKit.logger.warn("connectStatus is registered", {
+          caller: "Connect.register",
+          content: {
+            errCode: ErrorCode.CONNECT_CALL_STATUS_ERROR
+          }
+        });
         return;
       }
       this.callKit.logger.error("connectStatus is not init", {
-        errCode: ErrorCode.CONNECT_CALL_STATUS_ERROR
+        caller: "Connect.register",
+        content: {
+          errCode: ErrorCode.CONNECT_CALL_STATUS_ERROR
+        }
       });
-      this.callKit.callCenter.callEnd();
+      this.callKit.reset();
       return;
     }
-    this.callKit.logger.debug("connect register");
+    this.callKit.logger.info("connect register", {
+      caller: "Connect.register",
+      content: {
+        connectStatus: this.connectStatus
+      }
+    });
     await this.permission().catch((err) => {
       this.callKit.logger.error(err, {
-        errCode: ErrorCode.WEBRTC_USER_MEDIA_ERROR
+        caller: "Connect.register",
+        content: {
+          errCode: ErrorCode.WEBRTC_USER_MEDIA_ERROR
+        }
       });
+      this.callKit.reset();
     });
     const { userInfo, constrains } = this.callKit.config.getConfig();
     const localStreamFactory = async () => {
@@ -1132,12 +1058,18 @@ var Connect = class {
         }
       }
     };
-    this.callKit.logger.debug("connect connectConfig", connectConfig);
+    this.callKit.logger.info("connect connectConfig", {
+      caller: "Connect.register",
+      content: connectConfig
+    });
     this.userAgent = new import_sip.UserAgent(connectConfig);
     const remoteStream = new MediaStream();
     const setupRemoteMedia = (session) => {
       const audioRef = this.getAduioReference();
-      this.callKit.logger.debug("connect setupRemoteMedia", audioRef);
+      this.callKit.logger.info("connect setupRemoteMedia", {
+        caller: "Connect.register.setupRemoteMedia",
+        content: audioRef
+      });
       session.sessionDescriptionHandler.peerConnection.getReceivers().forEach((receiver) => {
         if (receiver.track) {
           remoteStream.addTrack(receiver.track);
@@ -1147,125 +1079,119 @@ var Connect = class {
         audioRef.srcObject = remoteStream;
         audioRef.play().catch((error) => {
           this.callKit.logger.error(error.message, {
-            errCode: ErrorCode.WEBRTC_AUDIO_PLAY_ERROR
+            caller: "Connect.register.setupRemoteMedia",
+            content: {
+              errCode: ErrorCode.WEBRTC_AUDIO_PLAY_ERROR
+            }
           });
         });
       } else {
         this.callKit.logger.error("video is not exist", {
-          errCode: ErrorCode.WEBRTC_AUDIO_PLAYER_ERROR
+          caller: "Connect.register",
+          content: {
+            errCode: ErrorCode.WEBRTC_AUDIO_PLAYER_ERROR
+          }
         });
       }
     };
     const observeSocketStatus = (userAgent, extra) => {
       const { that = this } = extra;
-      that.userAgent.transport.onDisconnect = (error) => {
-        if (error) {
-          that.callKit.logger.debug("connect onDisconnect");
-          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
-            });
-            that.callKit.user.sendHangUpReason({
-              eventType: ConnectEvent.SIP_CONNECT_ERROR,
-              err: error
-            });
-            that.callKit.callCenter.callEnd();
-          }
-        } else {
-          that.callKit.logger.debug("SIP WebSocket closed normally");
-        }
-      };
-      that.clearObserveOptionsHeartbeatInterval();
-      that.observeOptionsHeartbeatHandler = setInterval(() => {
-        if (that.lastOptionsUpdateTime !== 0) {
-          const now = (/* @__PURE__ */ new Date()).getTime();
-          const diff = now - that.lastOptionsUpdateTime;
-          if (diff > 6e4) {
-            that.callKit.trigger(KitEvent.CONNECT_EVENT, {
-              event: ConnectEvent.OPTIONS_HEARTBEAT_EXPIRED,
-              lastOptionsUpdateTime: that.lastOptionsUpdateTime,
-              now
-            });
-            that.callKit.user.sendHangUpReason({
-              eventType: ConnectEvent.OPTIONS_HEARTBEAT_EXPIRED,
-              lastOptionsUpdateTime: that.lastOptionsUpdateTime,
-              now
-            });
-            that.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
-              event: ConnectEvent.OPTIONS_HEARTBEAT_EXPIRED,
-              lastOptionsUpdateTime: that.lastOptionsUpdateTime,
-              now
-            });
-            that.clearObserveOptionsHeartbeatInterval();
-          }
-        }
-      }, 6e4);
-      that.lastOptionsUpdateTime = 0;
       const core = userAgent.userAgentCore;
       const originalReceiveRequest = core.receiveRequest.bind(core);
-      core.receiveRequest = function(request2) {
+      core.receiveRequest = (request2) => {
         if (request2.method === "OPTIONS") {
-          that.lastOptionsUpdateTime = (/* @__PURE__ */ new Date()).getTime();
+          that.startHeartbeat();
         }
-        that.callKit.logger.addLogData(LogDataEnum.SIP, request2);
+        that.callKit.logger.info(`SIP Receive Request: ${request2.method}`, {
+          caller: "Connect.register.observeSocketStatus",
+          type: "SIP",
+          content: {
+            request: request2
+          }
+        });
         return originalReceiveRequest(request2);
       };
+      const { transport } = userAgent;
+      if (transport) {
+        const originalSend = transport.send.bind(transport);
+        transport.send = (message) => {
+          that.callKit.logger.info(`SIP send message`, {
+            caller: "Connect.register.observeSocketStatus",
+            type: "SIP",
+            content: {
+              message: message.toString()
+            }
+          });
+          return originalSend(message);
+        };
+      }
     };
     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.callKit.logger.info("registerer stateChange Initial", {
+            caller: "Connect.register.registererStateChange",
+            type: "SIP",
+            content: {
+              registererState: state,
+              isRegistered: this.isRegistered
+            }
+          });
           this.setRegister(false);
           this.setConnectStatus(CallStatus.init);
-          this.callKit.user.setUserStatus(UserStatus.offline);
-          this.callKit.trigger(
-            KitEvent.SIP_REGISTERER_EVENT,
-            SipRegistererEvent.Initial
-          );
+          this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
+            registererState: state,
+            isRegistered: this.isRegistered
+          });
           break;
         case import_sip.RegistererState.Registered:
-          this.callKit.logger.debug("registerer stateChange Registered");
+          this.callKit.logger.info("registerer stateChange Registered", {
+            caller: "Connect.register.registererStateChange",
+            type: "SIP",
+            content: {
+              registererState: state,
+              isRegistered: this.isRegistered
+            }
+          });
           this.setRegister(true);
-          this.setConnectStatus(CallStatus.registered);
-          this.callKit.user.setUserStatus(UserStatus.online);
-          this.callKit.trigger(
-            KitEvent.SIP_REGISTERER_EVENT,
-            SipRegistererEvent.Registered
-          );
+          this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
+            registererState: state,
+            isRegistered: this.isRegistered
+          });
           break;
         case import_sip.RegistererState.Terminated:
-          this.callKit.logger.debug("registerer stateChange Terminated");
+          this.callKit.logger.info("registerer stateChange Terminated", {
+            caller: "Connect.register.registererStateChange",
+            type: "SIP",
+            content: {
+              registererState: state,
+              isRegistered: this.isRegistered
+            }
+          });
           this.setRegister(false);
           this.setConnectStatus(CallStatus.init);
-          this.callKit.user.setUserStatus(UserStatus.offline);
-          this.callKit.trigger(
-            KitEvent.SIP_REGISTERER_EVENT,
-            SipRegistererEvent.Terminated
-          );
+          this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
+            isRegistered: this.isRegistered,
+            registererState: state
+          });
           break;
         case import_sip.RegistererState.Unregistered:
-          this.callKit.logger.debug("registerer stateChange Unregistered");
+          this.callKit.logger.info("registerer stateChange Unregistered", {
+            caller: "Connect.register.registererStateChange",
+            type: "SIP",
+            content: {
+              isRegistered: this.isRegistered,
+              registererState: state
+            }
+          });
           this.setRegister(false);
           this.setConnectStatus(CallStatus.init);
-          this.callKit.user.setUserStatus(UserStatus.offline);
-          this.callKit.trigger(
-            KitEvent.SIP_REGISTERER_EVENT,
-            SipRegistererEvent.Unregistered
-          );
+          this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
+            isRegistered: this.isRegistered,
+            registererState: state
+          });
           break;
         default:
           break;
@@ -1273,64 +1199,75 @@ var Connect = class {
     });
     this.userAgent.delegate = {
       onInvite: (invite) => {
-        this.callKit.logger.debug("connect onInvite");
+        this.callKit.logger.info("connect onInvite", {
+          type: "SIP",
+          caller: "Connect.register.onInvite",
+          content: {
+            invite,
+            isRegistered: this.isRegistered
+          }
+        });
         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.callKit.logger.info("connect Establishing", {
+                caller: "Connect.register.onInvite",
+                type: "SIP",
+                content: {
+                  sessionState: state
+                }
+              });
               this.setConnectStatus(CallStatus.ringing);
-              if (!isExecuting) {
-                this.callKit.user.setUserStatus(UserStatus.busy);
-                this.callKit.trigger(
-                  KitEvent.SIP_SESSION_EVENT,
-                  SipSessionEvent.Establishing
-                );
-              }
+              this.callKit.trigger(KitEvent.SIP_SESSION_EVENT, {
+                sessionState: state,
+                isRegistered: this.isRegistered
+              });
               break;
             case import_sip.SessionState.Established:
-              this.callKit.logger.debug("connect Established");
+              this.callKit.logger.info("connect Established", {
+                caller: "Connect.register.onInvite",
+                type: "SIP",
+                content: {
+                  sessionState: state
+                }
+              });
               this.callKit.connect.setConnectStatus(CallStatus.calling);
-              if (!isExecuting) {
-                this.callKit.trigger(
-                  KitEvent.SIP_SESSION_EVENT,
-                  SipSessionEvent.Established
-                );
-                setupRemoteMedia(this.currentSession);
-              }
+              this.callKit.trigger(KitEvent.SIP_SESSION_EVENT, {
+                sessionState: state,
+                isRegistered: this.isRegistered
+              });
+              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
-                );
-              }
+              this.callKit.trigger(KitEvent.SIP_SESSION_EVENT, {
+                sessionState: state,
+                isRegistered: this.isRegistered
+              });
               break;
             case import_sip.SessionState.Terminated:
-              this.callKit.logger.debug("connect Terminated");
-              if (!this.isUnprompted) {
-                this.callKit.callCenter.callEnd();
-              } else if (this.isCalling()) {
+              this.callKit.logger.info("connect Terminated", {
+                caller: "Connect.register.onInvite",
+                type: "SIP",
+                content: {
+                  sessionState: state
+                }
+              });
+              if (this.isUnprompted) {
                 if (this.isCurrentSessionInvited) {
                   this.currentSession.reject();
                 }
-                this.callKit.callCenter.callEnd(true, false);
+              } else {
+                this.callKit.callCenter.callEnd();
               }
               this.isUnprompted = false;
-              if (!isExecuting) {
-                this.callKit.user.setUserStatus(UserStatus.catNap);
-                this.setConnectStatus(CallStatus.registered);
-                this.callKit.trigger(
-                  KitEvent.SIP_SESSION_EVENT,
-                  SipSessionEvent.Terminated
-                );
-              }
+              this.callKit.trigger(KitEvent.SIP_SESSION_EVENT, {
+                sessionState: state,
+                isRegistered: this.isRegistered
+              });
               break;
             default:
               break;
@@ -1344,6 +1281,7 @@ var Connect = class {
         };
         if (this.isOutgoing) {
           this.currentSession.accept(options);
+          this.setConnectStatus(CallStatus.connecting);
           this.callKit.trigger(KitEvent.KIT_OUTGOING_INVITE, {
             getInviteData: () => {
               const { request: request2 } = this.currentSession;
@@ -1354,20 +1292,18 @@ var Connect = class {
               ).forEach((name) => {
                 xHeaders[name.toLocaleLowerCase()] = request2.getHeader(name);
               });
-              this.callKit.logger.debug("get invite data", xHeaders);
+              this.callKit.logger.info("get invite data", {
+                caller: "Connect.register.onInvite",
+                content: 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.isCurrentSessionInvited = true;
@@ -1384,14 +1320,25 @@ var Connect = class {
               ).forEach((name) => {
                 xHeaders[name.toLocaleLowerCase()] = request2.getHeader(name);
               });
-              this.callKit.logger.debug("get invite data", xHeaders);
+              this.callKit.logger.info("get invite data", {
+                caller: "Connect.register",
+                content: xHeaders
+              });
               return xHeaders;
             }
           });
         }
       },
       onConnect: async () => {
-        this.callKit.logger.debug("connect onConnect");
+        this.reconnectAttempts = 0;
+        this.reconnectTimer = null;
+        this.callKit.logger.info("connect onConnect", {
+          caller: "Connect.register",
+          type: "SIP",
+          content: {
+            version: `V${this.callKit.config.getConfig().version}`
+          }
+        });
         const version = `V${this.callKit.config.getConfig().version}`;
         await this.registerer.register().then(() => {
           this.callKit.socket.send(SocketSendEvent.START, {
@@ -1399,132 +1346,148 @@ var Connect = class {
           });
         }).catch(async (err) => {
           this.callKit.logger.error(err?.message, {
-            errCode: ErrorCode.WEBRTC_REGISTER_ERROR
+            caller: "Connect.register",
+            type: "SIP",
+            content: {
+              errCode: ErrorCode.WEBRTC_REGISTER_ERROR
+            }
           });
+          this.callKit.reset();
         });
       },
       onDisconnect: (error) => {
-        this.callKit.logger.debug("connect onDisconnect");
-        if (this.isRegistered() && !// this.sipConnected ||
-        (this.isRinging() || this.isCalling() || this.isHolding())) {
-          this.reconnect();
+        console.log("onDisconnect", error);
+        if (error) {
+          this.startReconnectTimer();
         } 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
+          this.callKit.logger.info("SIP User Agent Disconnected", {
+            caller: "Connect.register",
+            type: "SIP",
+            content: {
+              err: error.message,
+              errCode: ErrorCode.WEBRTC_USER_AGENT_ERROR
+            }
           });
-          this.callKit.callCenter.callEnd();
         }
       },
       onRegister: () => {
-        this.callKit.logger.debug("connect onRegister");
+        this.callKit.logger.info("connect onRegister", {
+          caller: "Connect.register",
+          type: "SIP",
+          content: {
+            version: `V${this.callKit.config.getConfig().version}`
+          }
+        });
       }
-      // onRefer: (referral) => {
-      //   this.callKit.trigger(KitEvent.KIT_REFER, {
-      //     referAccept: () => {
-      //       this.setConnectStatus(CallStatus.connecting);
-      //       referral.accept().then(() => {
-      //         referral.makeInviter().invite();
-      //       });
-      //     },
-      //     referReject: () => {
-      //       referral.reject();
-      //       this.callKit.callCenter.callEnd(true, false);
-      //     }
-      //   });
-      // }
     };
     observeSocketStatus(this.userAgent, {
       that: this
     });
     await this.userAgent.start().catch((err) => {
-      this.callKit.callCenter.callEnd(false, true);
-      this.callKit.user.sendHangUpReason({
-        eventType: ConnectEvent.USER_AGENT_START_ERROR,
-        err
-      });
       this.callKit.logger.error(err, {
-        errCode: ErrorCode.WEBRTC_USER_AGENT_ERROR
+        caller: "Connect.register",
+        type: "SIP",
+        content: {
+          errCode: ErrorCode.WEBRTC_USER_AGENT_ERROR
+        }
       });
+      this.callKit.reset();
     });
   }
-  async reconnect() {
-    let currentRetry = 0;
-    let reconnectTimer = null;
-    const scheduleReconnect = async () => {
-      if (currentRetry >= this.reconnectConfig.maxAttempts) {
-        console.error("Maximum retry attempts reached, stopping reconnection");
-        return;
+  reconnectTimer;
+  reconnectAttempts = 0;
+  startReconnectTimer() {
+    if (this.reconnectAttempts >= this.reconnectConfig.maxAttempts) {
+      this.callKit.logger.error("Reconnect failed max attempts", {
+        caller: "Connect.startReconnectTimer",
+        type: "SIP",
+        content: {
+          errCode: ErrorCode.SOCKET_RECONNECT_FAILED,
+          maxAttempts: this.reconnectConfig.maxAttempts,
+          delay: this.reconnectConfig.delay
+        }
+      });
+      this.callKit.reset();
+      return;
+    }
+    this.callKit.logger.info("Reconnect timer started", {
+      caller: "Connect.startReconnectTimer",
+      type: "SIP",
+      content: {
+        reconnectAttempts: this.reconnectAttempts,
+        maxAttempts: this.reconnectConfig.maxAttempts,
+        delay: this.reconnectConfig.delay
       }
-      if (reconnectTimer)
-        return;
-      reconnectTimer = setTimeout(async () => {
-        try {
-          if (currentRetry === 0) {
-            this.callKit.trigger(KitEvent.CONNECT_EVENT, {
-              event: ConnectEvent.SIP_RECONNECT_START
-            });
+    });
+    this.reconnectAttempts += 1;
+    this.reconnectTimer = setTimeout(() => {
+      if (this.reconnectTimer) {
+        this.userAgent.reconnect();
+        this.callKit.logger.info("Reconnect attempt", {
+          caller: "Connect.startReconnectTimer",
+          type: "SIP",
+          content: {
+            reconnectAttempts: this.reconnectAttempts,
+            maxAttempts: this.reconnectConfig.maxAttempts,
+            delay: this.reconnectConfig.delay
           }
-          currentRetry += 1;
-          this.callKit.logger.debug(
-            `Attempting to reconnect SIP... (Attempt ${currentRetry}/${this.reconnectConfig.maxAttempts})`
-          );
-          await this.unregister();
-          await this.stop();
-          await this.register();
-          this.callKit.logger.debug(ConnectEvent.SIP_RECONNECT_SUCCESS);
-          this.callKit.trigger(KitEvent.CONNECT_EVENT, {
-            event: ConnectEvent.SIP_RECONNECT_SUCCESS
-          });
-          reconnectTimer = null;
-        } catch (err) {
-          this.callKit.logger.debug("Reconnection failed:", err);
-          reconnectTimer = null;
-          if (currentRetry < this.reconnectConfig.maxAttempts) {
-            await scheduleReconnect();
-          } else {
-            this.callKit.trigger(KitEvent.CONNECT_EVENT, {
-              event: ConnectEvent.SIP_RECONNECT_ERROR,
-              error: err
-            });
-            this.callKit.user.sendHangUpReason({
-              eventType: ConnectEvent.SIP_RECONNECT_ERROR,
-              error: err
-            });
-            this.callKit.logger.error("No registerer to unregister.");
+        });
+      } else {
+        this.callKit.logger.info("Reconnect timer already expired", {
+          caller: "Connect.startReconnectTimer",
+          type: "SIP",
+          content: {
+            reconnectAttempts: this.reconnectAttempts,
+            maxAttempts: this.reconnectConfig.maxAttempts,
+            delay: this.reconnectConfig.delay
           }
-        }
-      }, this.reconnectConfig.delay);
-    };
-    await scheduleReconnect();
+        });
+      }
+    }, this.reconnectConfig.delay);
   }
   async stop() {
     await this.userAgent.stop();
   }
   async unregister() {
-    this.callKit.logger.debug("connect unregister");
-    if (!this.isRegistered() || !this.registerer) {
-      this.callKit.logger.warn("No registerer to unregister.");
+    this.callKit.logger.info("connect unregister", {
+      caller: "Connect.unregister",
+      type: "SIP",
+      content: {
+        isRegistered: this.isRegistered,
+        registerer: this.registerer
+      }
+    });
+    if (!this.isRegistered || !this.registerer) {
+      this.callKit.logger.warn("No registerer to unregister.", {
+        caller: "Connect.unregister",
+        type: "SIP",
+        content: {
+          errCode: ErrorCode.WEBRTC_CANCEL_REGISTER_ERROR
+        }
+      });
       return;
     }
     await this.registerer.unregister({ all: true }).catch((err) => {
       this.callKit.logger.error(err, {
-        errCode: ErrorCode.WEBRTC_CANCEL_REGISTER_ERROR
+        caller: "Connect.unregister",
+        type: "SIP",
+        content: {
+          errCode: ErrorCode.WEBRTC_CANCEL_REGISTER_ERROR
+        }
       });
+      this.callKit.reset();
     });
   }
   async call(callback) {
-    this.callKit.logger.debug("connect call");
+    this.callKit.logger.info("connect call", {
+      caller: "Connect.call",
+      type: "SIP",
+      content: {
+        callback
+      }
+    });
     this.isOutgoing = true;
-    if (!this.isRegistered()) {
+    if (!this.isRegistered) {
       await this.register();
     }
     this.setConnectStatus(CallStatus.connecting);
@@ -1537,7 +1500,14 @@ var Connect = class {
    * @param register
    */
   setRegister(register) {
-    this.callKit.logger.debug(`connect setRegister:${register}`);
+    this.callKit.logger.info("connect setRegister", {
+      caller: "Connect.setRegister",
+      type: "SIP",
+      content: {
+        register
+      }
+    });
+    this.isRegistered = register;
     this.callKit.trigger(KitEvent.KIT_REGISTER_CHANGE, register);
   }
   /**
@@ -1545,7 +1515,13 @@ var Connect = class {
    * @param status
    */
   setConnectStatus(status) {
-    this.callKit.logger.debug(`connect setConnectStatus: ${status}`);
+    this.callKit.logger.info("connect setConnectStatus", {
+      caller: "Connect.setConnectStatus",
+      type: "SIP",
+      content: {
+        status
+      }
+    });
     this.connectStatus = status;
     this.callKit.trigger(KitEvent.KIT_CALL_STATUS_CHANGE, status);
   }
@@ -1556,8 +1532,16 @@ var Connect = class {
    * @returns
    */
   async hangup(isUnprompted = false, isError = false) {
-    this.callKit.logger.debug(`connect hangup isError: ${isError}`);
-    if (this.connectStatus === CallStatus.init || this.connectStatus === CallStatus.registered)
+    this.callKit.logger.info("connect hangup", {
+      caller: "Connect.hangup",
+      type: "SIP",
+      content: {
+        isUnprompted,
+        isError,
+        connectStatus: this.connectStatus
+      }
+    });
+    if (this.connectStatus === CallStatus.init)
       return;
     this.isOutgoing = false;
     this.isUnprompted = isUnprompted;
@@ -1577,12 +1561,20 @@ var Connect = class {
         audioRef.pause();
         audioRef.srcObject = null;
       }
-      if (isError) {
-        this.setConnectStatus(CallStatus.init);
-      }
+      this.setConnectStatus(CallStatus.init);
       this.callKit.trigger(KitEvent.CALL_END, /* @__PURE__ */ new Date());
     } catch (err) {
+      this.callKit.logger.error(err, {
+        caller: "Connect.hangup",
+        type: "SIP",
+        content: {
+          connectStatus: this.connectStatus,
+          isError,
+          isUnprompted
+        }
+      });
       this.callKit.trigger(KitEvent.CALL_END, /* @__PURE__ */ new Date());
+      this.callKit.reset();
     }
   }
   /**
@@ -1590,7 +1582,13 @@ var Connect = class {
    * @param session - Session to get the media stream from.
    */
   getRemoteMediaStream(session) {
-    this.callKit.logger.debug("connect getRemoteMediaStream");
+    this.callKit.logger.info("connect getRemoteMediaStream", {
+      caller: "Connect.getRemoteMediaStream",
+      type: "SIP",
+      content: {
+        session
+      }
+    });
     const sdh = session.sessionDescriptionHandler;
     if (!sdh) {
       return void 0;
@@ -1598,7 +1596,13 @@ var Connect = class {
     return sdh.remoteMediaStream;
   }
   setupRemoteMedia(session) {
-    this.callKit.logger.debug("connect setupRemoteMedia");
+    this.callKit.logger.info("connect setupRemoteMedia", {
+      caller: "Connect.setupRemoteMedia",
+      type: "SIP",
+      content: {
+        session
+      }
+    });
     const remoteStream = this.getRemoteMediaStream(session);
     const audioRef = this.getAduioReference();
     if (audioRef) {
@@ -1606,21 +1610,39 @@ var Connect = class {
       audioRef.srcObject = remoteStream;
       audioRef.play().catch((error) => {
         this.callKit.logger.error(error.message, {
-          errCode: ErrorCode.WEBRTC_AUDIO_PLAY_ERROR
+          caller: "Connect.setupRemoteMedia",
+          type: "SIP",
+          content: {
+            errCode: ErrorCode.WEBRTC_AUDIO_PLAY_ERROR
+          }
         });
       });
       remoteStream.onaddtrack = () => {
-        this.callKit.logger.debug("Remote media onaddtrack");
+        this.callKit.logger.info("Remote media onaddtrack", {
+          caller: "Connect.setupRemoteMedia",
+          type: "SIP",
+          content: {
+            session
+          }
+        });
         audioRef.load();
         audioRef.play().catch((error) => {
           this.callKit.logger.error(error.message, {
-            errCode: ErrorCode.WEBRTC_AUDIO_PLAY_ERROR
+            caller: "Connect.setupRemoteMedia",
+            type: "SIP",
+            content: {
+              errCode: ErrorCode.WEBRTC_AUDIO_PLAY_ERROR
+            }
           });
         });
       };
     } else {
       this.callKit.logger.error("video is not exist", {
-        errCode: ErrorCode.WEBRTC_AUDIO_PLAYER_ERROR
+        caller: "Connect.setupRemoteMedia",
+        type: "SIP",
+        content: {
+          errCode: ErrorCode.WEBRTC_AUDIO_PLAYER_ERROR
+        }
       });
     }
   }
@@ -1629,33 +1651,62 @@ var Connect = class {
    * @param hold
    */
   setHoldStatus(hold) {
-    this.callKit.logger.debug("connect setHold", hold);
-    this.isHold = hold;
+    this.callKit.logger.info("connect setHold", {
+      caller: "Connect.setHoldStatus",
+      type: "SIP",
+      content: {
+        hold
+      }
+    });
     this.callKit.trigger(KitEvent.KIT_SET_HOLD, hold);
   }
   async setHold(hold) {
     this.setHoldStatus(hold);
   }
   async hold() {
-    this.callKit.logger.debug("connect hold");
+    this.callKit.logger.info("connect hold", {
+      caller: "Connect.hold",
+      type: "SIP",
+      content: {
+        hold: true
+      }
+    });
     if (this.connectStatus !== CallStatus.calling || !this.currentSession) {
       this.callKit.logger.error("Current status is not in call", {
-        errCode: ErrorCode.WEBRTC_HOLE_STATUS_ERROR
+        caller: "Connect.hold",
+        type: "SIP",
+        content: {
+          errCode: ErrorCode.WEBRTC_HOLE_STATUS_ERROR
+        }
       });
-      return;
     }
-    await this.setHold(true);
   }
   async unhold() {
-    this.callKit.logger.debug("connect unhold");
-    await this.setHold(false);
+    this.callKit.logger.info("connect unhold", {
+      caller: "Connect.unhold",
+      type: "SIP",
+      content: {
+        hold: false
+      }
+    });
   }
   async setMute(mute) {
-    this.callKit.logger.debug("connect setMute", mute);
+    this.callKit.logger.info("connect setMute", {
+      caller: "Connect.setMute",
+      type: "SIP",
+      content: {
+        mute
+      }
+    });
     if (!this.currentSession) {
       this.callKit.logger.error("No active session", {
-        errCode: ErrorCode.WEBRTC_MUTE_STATUS_ERROR
+        caller: "Connect.setMute",
+        type: "SIP",
+        content: {
+          errCode: ErrorCode.WEBRTC_MUTE_STATUS_ERROR
+        }
       });
+      this.callKit.reset();
       return;
     }
     try {
@@ -1674,33 +1725,64 @@ var Connect = class {
       }
     } catch (error) {
       this.callKit.logger.error("Failed to set mute state", {
-        errCode: ErrorCode.WEBRTC_MUTE_ERROR,
-        error
+        caller: "Connect.setMute",
+        type: "SIP",
+        content: {
+          err: error.message,
+          errCode: ErrorCode.WEBRTC_MUTE_ERROR
+        }
       });
     }
   }
   async mute() {
-    this.callKit.logger.debug("connect mute");
+    this.callKit.logger.info("connect mute", {
+      caller: "Connect.mute",
+      type: "SIP",
+      content: {
+        mute: true
+      }
+    });
     if (this.connectStatus !== CallStatus.calling || !this.currentSession) {
-      this.callKit.logger.error("Current status is not in call", {
-        errCode: ErrorCode.WEBRTC_MUTE_STATUS_ERROR
+      this.callKit.logger.warn("Current status is not in call", {
+        caller: "Connect.mute",
+        type: "SIP",
+        content: {
+          errCode: ErrorCode.WEBRTC_MUTE_STATUS_ERROR
+        }
       });
       return;
     }
     await this.setMute(true);
   }
   async unmute() {
-    this.callKit.logger.debug("connect unmute");
+    this.callKit.logger.info("connect unmute", {
+      caller: "Connect.unmute",
+      type: "SIP",
+      content: {
+        mute: false
+      }
+    });
     if (this.connectStatus !== CallStatus.calling || !this.currentSession) {
-      this.callKit.logger.error("Current status is not in call", {
-        errCode: ErrorCode.WEBRTC_MUTE_STATUS_ERROR
+      this.callKit.logger.warn("Current status is not in call", {
+        caller: "Connect.unmute",
+        type: "SIP",
+        content: {
+          errCode: ErrorCode.WEBRTC_MUTE_STATUS_ERROR
+        }
       });
       return;
     }
     await this.setMute(false);
   }
   async refer(referTo, extra) {
-    this.callKit.logger.debug("connect refer");
+    this.callKit.logger.info("connect refer", {
+      caller: "Connect.refer",
+      type: "SIP",
+      content: {
+        referTo,
+        extra
+      }
+    });
     let target;
     if (referTo) {
       target = import_sip.UserAgent.makeURI(referTo);
@@ -1725,8 +1807,6 @@ var Socket = class {
   lastPingTime = void 0;
   isConnected = false;
   pingTimer;
-  // Whether received server hangup confirmation
-  recivedClose = false;
   // Whether received start confirmation
   satrtConfirm = false;
   reconnectTimer;
@@ -1742,48 +1822,25 @@ var Socket = class {
   }
   init() {
     const { socket } = this.callKit.config.getConfig();
-    this.callKit.logger.debug(`socket init: ${socket}`);
+    this.callKit.logger.info(`socket init: ${socket}`, {
+      caller: "Socket.init",
+      type: "INCALL",
+      content: {
+        socket
+      }
+    });
     this.connect(socket);
   }
-  // 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);
+  handleDisconnect() {
     this.isConnected = false;
-    if (!this.isReconnecting && this.socketConfig.maxAttempts > 0) {
-      this.callKit.logger.debug(
-        "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) {
+    if (!this.callKit.config.isLogin() || !this.socketConfig.enabled) {
+      this.reset();
       this.callKit.trigger(KitEvent.CONNECT_EVENT, {
-        event: ConnectEvent.INCALL_RECONNECT_ERROR,
-        err: ev
+        event: "INCALL_NOT_CONNECTED"
       });
-      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",
-        {
-          errCode: ErrorCode.SOCKET_RECONNECT_FAILED
-        }
-      );
+      return;
     }
+    this.attemptReconnect();
   }
   connect(socketUrl) {
     this.ws = new WebSocket(socketUrl);
@@ -1793,86 +1850,76 @@ var Socket = class {
     this.ws.onmessage = (ev) => this.onMessage(ev);
   }
   onOpen(ev) {
-    this.callKit.logger.debug("socket onOpen", ev);
-    this.callKit.logger.addLogData(LogDataEnum.INCALL, {
-      callKitSocketFrom: "onOpen",
-      ev
+    this.callKit.logger.info("socket onOpen", {
+      caller: "Socket.onOpen",
+      type: "INCALL",
+      content: { ev }
     });
     this.isConnected = true;
     this.lastPingTime = Date.now();
     this.checkPing();
     if (this.isReconnecting) {
-      this.callKit.logger.debug(ConnectEvent.INCALL_RECONNECT_SUCCESS);
+      this.callKit.logger.info("reconnect success", {
+        caller: "Socket.onOpen",
+        type: "INCALL",
+        content: {
+          event: "INCALL_RECONNECT_SUCCESS",
+          reconnectAttempts: this.reconnectAttempts
+        }
+      });
       this.callKit.trigger(KitEvent.CONNECT_EVENT, {
-        event: ConnectEvent.INCALL_RECONNECT_SUCCESS
+        event: "INCALL_RECONNECT_SUCCESS"
       });
-      this.isReconnecting = false;
-      if (this.reconnectTimer) {
-        clearTimeout(this.reconnectTimer);
-        this.reconnectTimer = void 0;
-      }
     }
+    this.resetReconnectState();
+  }
+  resetReconnectState() {
+    this.isReconnecting = false;
     this.reconnectAttempts = 0;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
+    }
   }
   onClose(ev) {
-    this.callKit.logger.debug("socket onClose", ev);
-    this.callKit.logger.addLogData(LogDataEnum.INCALL, {
-      callKitSocketFrom: "onClose",
-      ev
+    this.callKit.logger.info("socket onClose", {
+      caller: "Socket.onClose",
+      type: "INCALL",
+      content: { 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;
-      this.satrtConfirm = false;
-      if (this.pingTimer) {
-        clearInterval(this.pingTimer);
-        this.pingTimer = void 0;
-      }
-      this.callKit.connect.hangup();
-      this.reset();
-    }
+    this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+      event: "INCALL_CONNECT_ERROR",
+      err: ev
+    });
+    this.handleDisconnect();
   }
   onError(ev) {
-    this.callKit.logger.debug("socket onError", {
-      errCode: ErrorCode.SOCKET_CONNECT_ERROR,
-      data: ev
-    });
-    this.callKit.logger.addLogData(LogDataEnum.INCALL, {
-      callKitSocketFrom: "onError",
-      ev
+    this.callKit.logger.error("socket onError", {
+      caller: "Socket.onError",
+      type: "INCALL",
+      content: {
+        errCode: ErrorCode.SOCKET_CONNECT_ERROR,
+        data: 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.callKit.logger.info("socket onMessage", {
+      caller: "Socket.onMessage",
+      type: "INCALL",
+      content: {
+        data: data.data,
+        event: data.event
+      }
     });
     this.confirmAck(data);
     if (data.event === SocketReceiveEvent.PONG) {
@@ -1880,69 +1927,147 @@ var Socket = class {
       return;
     }
     if (data.event === SocketReceiveEvent.START_CONFIRM) {
-      this.callKit.logger.debug("start confirm success");
+      this.callKit.logger.info("start confirm success", {
+        caller: "Socket.onMessage",
+        type: "INCALL",
+        content: {
+          data: data.data,
+          event: SocketReceiveEvent.START_CONFIRM
+        }
+      });
       this.satrtConfirm = true;
     }
     if (data.event === SocketReceiveEvent.CALL_SUCCESS) {
-      this.recivedClose = false;
+      this.callKit.logger.info("call success", {
+        caller: "Socket.onMessage",
+        type: "INCALL",
+        content: {
+          data: data.data,
+          event: SocketReceiveEvent.CALL_SUCCESS
+        }
+      });
     }
     if (data.event === SocketReceiveEvent.CALL_FAILED) {
-      this.callKit.logger.debug(data.msg, {
-        errCode: ErrorCode.SOCKET_CALL_ERROR
+      this.callKit.logger.info(data.msg, {
+        caller: "Socket.onMessage",
+        type: "INCALL",
+        content: {
+          data: data.data,
+          errCode: ErrorCode.SOCKET_CALL_ERROR
+        }
       });
     }
     if (data.event === SocketReceiveEvent.CUSTOMER_RINGING) {
       this.callKit.trigger(KitEvent.CALL_RINGING, /* @__PURE__ */ new Date());
     }
     if (data.event === SocketReceiveEvent.CUSTOMER_PICK_UP) {
-      this.callKit.logger.debug(data.msg);
+      this.callKit.logger.info(data.msg, {
+        caller: "Socket.onMessage",
+        type: "INCALL",
+        content: {
+          data: data.data,
+          event: SocketReceiveEvent.CUSTOMER_PICK_UP
+        }
+      });
       this.callKit.trigger(KitEvent.CALL_PICK_UP, /* @__PURE__ */ new Date());
     }
     if (data.event === SocketReceiveEvent.AGENT_PICK_UP) {
-      this.callKit.logger.debug(data.msg);
+      this.callKit.logger.info(data.msg, {
+        caller: "Socket.onMessage",
+        type: "INCALL",
+        content: {
+          data: data.data,
+          event: SocketReceiveEvent.AGENT_PICK_UP
+        }
+      });
       this.callKit.trigger(KitEvent.AGENT_PICK_UP, /* @__PURE__ */ new Date());
     }
     if (data.event === SocketReceiveEvent.CUSTOMER_HANG_UP) {
-      this.callKit.logger.debug(data.msg);
+      this.callKit.logger.info(data.msg, {
+        caller: "Socket.onMessage",
+        type: "INCALL",
+        content: {
+          data: data.data,
+          event: SocketReceiveEvent.CUSTOMER_HANG_UP
+        }
+      });
       this.callKit.trigger(KitEvent.CALL_HANG_UP, /* @__PURE__ */ new Date());
     }
     if (data.event === SocketReceiveEvent.CUSTOMER_NO_ANSWER) {
-      this.callKit.logger.debug(data.msg);
+      this.callKit.logger.info(data.msg, {
+        caller: "Socket.onMessage",
+        type: "INCALL",
+        content: {
+          data: data.data,
+          event: SocketReceiveEvent.CUSTOMER_NO_ANSWER
+        }
+      });
       this.callKit.trigger(KitEvent.CALL_NO_ANSWER);
     }
     if (data.event === SocketReceiveEvent.CALL_CDR) {
-      this.callKit.logger.debug(data.msg);
+      this.callKit.logger.info(data.msg, {
+        caller: "Socket.onMessage",
+        content: {
+          data: data.data,
+          event: SocketReceiveEvent.CALL_CDR
+        }
+      });
       this.callKit.trigger(KitEvent.CALL_CDR, data.data);
     }
     if (data.event === SocketReceiveEvent.STOP_CONFIRM) {
-      this.callKit.logger.debug(data.msg);
-      this.setRecivedClose(true);
+      this.callKit.logger.info(data.msg, {
+        caller: "Socket.onMessage",
+        content: {
+          data: data.data,
+          event: SocketReceiveEvent.STOP_CONFIRM
+        }
+      });
     }
     if (data.event === SocketReceiveEvent.CLOSE) {
       const { userInfo } = this.callKit.config.getConfig();
-      this.callKit.logger.debug(data.msg);
+      this.callKit.logger.info(data.msg, {
+        caller: "Socket.onMessage",
+        content: {
+          data: data.data,
+          event: SocketReceiveEvent.CLOSE
+        }
+      });
       this.send(SocketSendEvent.END, {
         agentId: userInfo.agentId
       });
     }
     if (data.event === SocketReceiveEvent.ERROR) {
-      this.callKit.unregister();
-      this.callKit.logger.debug(data.msg, {
-        errCode: ErrorCode.SOKET_SERVER_ERROR,
-        data
+      this.callKit.logger.error(data.msg, {
+        caller: "Socket.onMessage",
+        content: {
+          errCode: ErrorCode.SOKET_SERVER_ERROR,
+          data: data.data
+        }
       });
+      this.callKit.reset();
     }
     if (data.event === SocketReceiveEvent.AGENT_NO_ANSWER) {
+      this.callKit.logger.info(data.msg, {
+        caller: "Socket.onMessage",
+        content: {
+          data: data.data,
+          event: SocketReceiveEvent.AGENT_NO_ANSWER
+        }
+      });
     }
     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
+        event: "INCALL_NOT_CONNECTED"
       });
       this.callKit.logger.error("socket not connected", {
-        errCode: ErrorCode.SOCKET_CONNECT_ERROR
+        caller: "Socket.send",
+        type: "INCALL",
+        content: {
+          errCode: ErrorCode.SOCKET_CONNECT_ERROR
+        }
       });
       this.callKit.config.reset();
       this.callKit.reset();
@@ -1952,7 +2077,11 @@ var Socket = class {
     const { sessionId, extno, agentId } = userInfo;
     if (!sessionId) {
       this.callKit.logger.error("sessionId is empty", {
-        errCode: ErrorCode.SOCKET_CONNECT_ERROR
+        caller: "Socket.send",
+        type: "INCALL",
+        content: {
+          errCode: ErrorCode.SOCKET_CONNECT_ERROR
+        }
       });
       return;
     }
@@ -1970,7 +2099,14 @@ var Socket = class {
         delete msg.phoneNum;
       }
     }
-    this.callKit.logger.debug("socket send", msg);
+    this.callKit.logger.info("socket send", {
+      caller: "Socket.send",
+      type: "INCALL",
+      content: {
+        event,
+        message
+      }
+    });
     switch (event) {
       case SocketSendEvent.PING:
         this.lastPingTime = Date.now();
@@ -1984,10 +2120,14 @@ var Socket = class {
   async sendMessage(event, message) {
     if (!this.isConnected) {
       this.callKit.trigger(KitEvent.CONNECT_EVENT, {
-        event: ConnectEvent.INCALL_NOT_CONNECTED
+        event: "INCALL_NOT_CONNECTED"
       });
       this.callKit.logger.error("socket not connected", {
-        errCode: ErrorCode.SOCKET_CONNECT_ERROR
+        caller: "Socket.sendMessage",
+        type: "INCALL",
+        content: {
+          errCode: ErrorCode.SOCKET_CONNECT_ERROR
+        }
       });
       return;
     }
@@ -1995,32 +2135,26 @@ var Socket = class {
     const { sessionId } = userInfo;
     this.ws?.send(JSON.stringify({ event, sessionId, ...message }));
   }
-  /**
-   * Attempt to close socket, need to wait for server confirmation
-   * @returns
-   */
-  async requestClose() {
-    return new Promise((resolve) => {
-      let remainingTime = 5;
-      const interval = setInterval(() => {
-        remainingTime -= 1;
-        if (this.recivedClose || remainingTime <= 0) {
-          clearInterval(interval);
-          resolve(this.recivedClose);
-        }
-      }, 1e3);
-    });
-  }
   ping() {
     if (!this.isConnected)
       return;
     this.send(SocketSendEvent.PING);
+    this.callKit.logger.info(`socket ping`, {
+      caller: "Socket.ping",
+      type: "INCALL",
+      content: {
+        lastPingTime: this.lastPingTime
+      }
+    });
     const now = Date.now();
-    this.callKit.logger.debug(`socket ping: ${now - this.lastPingTime}ms`);
     const { pingInterval, pingTimeout } = this.socketConfig;
     if (now - this.lastPingTime > pingInterval + pingTimeout) {
       this.callKit.logger.error("socket ping timeout", {
-        errCode: ErrorCode.SOCKET_PING_TIMEOUT
+        caller: "Socket.ping",
+        type: "INCALL",
+        content: {
+          errCode: ErrorCode.SOCKET_PING_TIMEOUT
+        }
       });
       if (this.ws && this.isConnected) {
         this.ws.close(4001, "ping timeout");
@@ -2039,257 +2173,72 @@ var Socket = class {
     }, this.socketConfig.pingInterval);
   }
   /**
-   *
+   * 重置 socket 连接和所有状态
    * @param isWaitConfirm Whether need to wait for close confirmation
    */
   async reset(isWaitConfirm = true) {
     if (this.pingTimer) {
       clearInterval(this.pingTimer);
+      this.pingTimer = void 0;
     }
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-    }
+    this.resetReconnectState();
     this.lastPingTime = void 0;
-    this.pingTimer = void 0;
     this.satrtConfirm = false;
-    this.isReconnecting = false;
-    this.reconnectAttempts = 0;
     if (this.ws && this.isConnected) {
-      if (isWaitConfirm) {
-        await this.requestClose();
-      }
-      this.recivedClose = false;
-      this.callKit.logger.debug("socket destroy");
+      this.callKit.logger.info("Closing socket connection", {
+        caller: "Socket.reset",
+        type: "INCALL",
+        content: {
+          isWaitConfirm
+        }
+      });
       this.ws.close();
       this.isConnected = false;
     }
   }
   attemptReconnect() {
-    if (this.reconnectAttempts === 0) {
-      this.callKit.trigger(KitEvent.CONNECT_EVENT, {
-        event: ConnectEvent.INCALL_RECONNECT_START
+    if (this.reconnectAttempts >= this.socketConfig.maxAttempts) {
+      this.callKit.logger.error("Maximum reconnection attempts reached", {
+        caller: "Socket.attemptReconnect",
+        type: "INCALL",
+        content: {
+          errCode: ErrorCode.SOCKET_RECONNECT_FAILED,
+          reconnectAttempts: this.reconnectAttempts
+        }
       });
-    }
-    if (this.isReconnecting && this.reconnectAttempts >= this.socketConfig.maxAttempts) {
       this.callKit.trigger(KitEvent.CONNECT_EVENT, {
-        event: ConnectEvent.INCALL_RECONNECT_ERROR
+        event: "INCALL_RECONNECT_ERROR"
       });
-      this.isReconnecting = false;
       this.reset();
       return;
     }
+    if (this.reconnectAttempts === 0) {
+      this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+        event: "INCALL_RECONNECT_START"
+      });
+    }
     this.isReconnecting = true;
     this.reconnectAttempts += 1;
     const { delay } = this.socketConfig;
-    this.callKit.logger.debug(
-      `Preparing reconnection attempt ${this.reconnectAttempts}/${this.socketConfig.maxAttempts}, delay: ${delay}ms`
+    this.callKit.logger.info(
+      `Preparing reconnection attempt ${this.reconnectAttempts}/${this.socketConfig.maxAttempts}, delay: ${delay}ms`,
+      {
+        caller: "Socket.attemptReconnect",
+        type: "INCALL",
+        content: {
+          reconnectAttempts: this.reconnectAttempts,
+          maxAttempts: this.socketConfig.maxAttempts,
+          delay
+        }
+      }
     );
     this.reconnectTimer = setTimeout(() => {
       const { socket } = this.callKit.config.getConfig();
       this.connect(socket);
-      this.callKit.logger.debug("Reconnection attempt failed");
-      if (this.reconnectAttempts >= this.socketConfig.maxAttempts) {
-        this.callKit.trigger(KitEvent.CONNECT_EVENT, {
-          event: ConnectEvent.INCALL_RECONNECT_ERROR
-        });
-        this.isReconnecting = false;
-        this.reset();
-      }
     }, delay);
   }
 };
 
-// package/user.ts
-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
-      });
-    });
-  }
-  /**
-   *
-   * @param status logout(1, "unregistered"), idle(2, "free"), break(3, "nap"), busy(4, "busy")
-   */
-  async setUserStatus(status) {
-    const { isAutoUpdateUserStatus } = this.callKit.config.getConfig();
-    if (status === this.userStatus || !isAutoUpdateUserStatus)
-      return;
-    return this.updateUserStatus(status);
-  }
-  /**
-   * Update user status
-   * @param status
-   */
-  async updateUserStatus(status) {
-    if (this.userChangeStatusExecuting)
-      return;
-    const { agentId } = this.callKit.config.getConfig().userInfo;
-    this.setUserChangeStatusExecuting(true);
-    const postData = {
-      agentId,
-      userStatus: status
-    };
-    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 || {};
-      this.callKit.socket.sendMessage(SocketSendEvent.HANG_UP_REASON, sendData);
-    } catch (error) {
-      this.callKit.logger.debug(error);
-    }
-  }
-};
-
 // package/index.ts
 var CallKit = class {
   api;
@@ -2298,11 +2247,15 @@ var CallKit = class {
   callCenter;
   connect;
   socket;
-  user;
   listener = [];
   constructor(options) {
     this.config = new Config(this);
+    this.api = new Api(this);
+    this.connect = new Connect(this);
+    this.callCenter = new Call(this);
+    this.socket = new Socket(this);
     this.config.setConfig("log", options.log);
+    this.config.setConfig("trackLogs", options.trackLogs);
     this.config.setConfig("audioRef", options.audioRef);
     this.config.setConfig("host", options.host);
     this.config.setConfig(
@@ -2310,24 +2263,21 @@ var CallKit = class {
       options.constrains || constrainsDefault
     );
     this.config.setConfig("socket", options.socket);
-    this.config.setConfig(
-      "isAutoUpdateUserStatus",
-      options.isAutoUpdateUserStatus === void 0 ? isAutoUpdateUserStatusDefault : options.isAutoUpdateUserStatus
-    );
     this.config.setConfig("reconnect", options.reconnect);
     this.logger = new Logger(this, options.log);
-    this.logger.debug("callKit init", options);
-    this.api = new Api(this);
-    this.connect = new Connect(this);
-    this.callCenter = new Call(this);
-    this.socket = new Socket(this);
-    this.user = new User(this);
+    this.logger.info("callKit init", {
+      caller: "CallKit.init",
+      content: options
+    });
   }
   async login(username, password, extra = {
     encryptionMethod: EncryptionMethod.INTERNAL
   }) {
     if (this.config.isLogin()) {
-      this.logger.warn("already login");
+      this.logger.warn("already login", {
+        caller: "CallKit.login",
+        content: { username, password, extra }
+      });
       return;
     }
     let encryptionPassword = "";
@@ -2343,48 +2293,73 @@ var CallKit = class {
         encryptionPassword = (0, import_blueimp_md5.default)(username + (0, import_blueimp_md5.default)(password));
         break;
     }
-    this.logger.debug("login info:", {
-      username,
-      password,
-      encryptionMethod,
-      encryptionPassword
-    });
-    const user = await this.user.login({
-      userName: username,
-      password: encryptionPassword
-    });
-    if (user) {
-      this.config.setConfig("userInfo", {
-        wsUrl: `wss://${user.wsUrl}`,
-        sessionId: user.sessionId,
+    this.logger.info("login info:", {
+      caller: "CallKit.login",
+      content: {
         username,
-        password: encryptionPassword,
-        encryptionPassword,
-        agentId: user.agentId,
-        fsUserId: user.fsUserId,
-        userPart: user.userPart,
-        fsPassword: user.fsPassword,
-        fsIp: user.fsIp,
-        fsPort: user.fsPort,
-        iceInfo: user.iceInfo,
-        iceGatheringTimeout: user.iceGatheringTimeout,
-        logGather: user.logGather,
-        // encryptionType is in extra
-        ...extra
+        password,
+        encryptionMethod,
+        encryptionPassword
+      }
+    });
+    try {
+      const user = await this.api.login({
+        userName: username,
+        password: encryptionPassword
+      });
+      if (user) {
+        this.config.setConfig("userInfo", {
+          wsUrl: `wss://${user.wsUrl}`,
+          sessionId: user.sessionId,
+          username,
+          password: encryptionPassword,
+          encryptionPassword,
+          agentId: user.agentId,
+          fsUserId: user.fsUserId,
+          userPart: user.userPart,
+          fsPassword: user.fsPassword,
+          fsIp: user.fsIp,
+          fsPort: user.fsPort,
+          iceInfo: user.iceInfo,
+          iceGatheringTimeout: user.iceGatheringTimeout,
+          logGather: user.logGather,
+          // encryptionType is in extra
+          ...extra
+        });
+        this.socket.init();
+        this.trigger(KitEvent.KIT_LOGIN_CHANGE, true);
+      }
+    } catch (error) {
+      this.logger.error(error, {
+        caller: "CallKit.login",
+        content: {
+          errCode: ErrorCode.API_USER_LOGIN_ERROR
+        }
       });
-      this.socket.init();
-      this.trigger(KitEvent.KIT_LOGIN_CHANGE, true);
-      this.user.setUserStatus(UserStatus.offline);
     }
   }
   async logout() {
     if (!this.config.check())
       return;
-    this.logger.debug("logout");
-    await this.user.setUserStatus(UserStatus.offline);
+    const { userInfo } = this.config.getConfig();
+    this.logger.info("logout", {
+      caller: "CallKit.logout",
+      content: {
+        sessionId: userInfo.sessionId
+      }
+    });
     if (this.config.isLogin()) {
-      const { sessionId } = this.config.getConfig().userInfo;
-      this.user.loginOut({ sessionId });
+      const { sessionId } = userInfo;
+      try {
+        await this.api.loginOut({ sessionId });
+      } catch (error) {
+        this.logger.error(error, {
+          caller: "CallKit.logout",
+          content: {
+            errCode: ErrorCode.API_USER_LOGOUT_ERROR
+          }
+        });
+      }
     }
     await this.hangup();
     this.socket.reset(false);
@@ -2398,8 +2373,11 @@ var CallKit = class {
   }) {
     if (!this.config.check())
       return;
-    if (!this.connect.isRegistered()) {
-      this.logger.warn("Currently not registered");
+    if (!this.connect.isRegistered) {
+      this.logger.warn("Currently not registered", {
+        caller: "CallKit.call",
+        content: { extno, options }
+      });
       return;
     }
     const { sourceType, workOrderId } = options;
@@ -2413,25 +2391,43 @@ var CallKit = class {
         this.config.setUserInfo("workOrderId", workOrderId);
       }
     }
-    this.logger.debug("call");
+    this.logger.info("call", {
+      caller: "CallKit.call",
+      content: {
+        extno,
+        options
+      }
+    });
     this.callCenter.callStart();
   }
   async refer(uri, options) {
     if (!this.config.check())
       return;
-    this.logger.debug("refer");
+    this.logger.info("refer", {
+      caller: "CallKit.refer",
+      content: {
+        uri,
+        options
+      }
+    });
     this.callCenter.callRefer(uri, options);
   }
   async register() {
     if (!this.config.check())
       return;
-    this.logger.debug("register");
+    this.logger.info("register", {
+      caller: "CallKit.register",
+      content: {}
+    });
     this.connect.register();
   }
   async unregister() {
     if (!this.config.check())
       return;
-    this.logger.debug("unregister");
+    this.logger.info("unregister", {
+      caller: "CallKit.unregister",
+      content: {}
+    });
     this.connect.unregister();
   }
   async stop() {
@@ -2440,9 +2436,19 @@ var CallKit = class {
   async hangup() {
     if (!this.config.check())
       return;
-    this.logger.debug("hangup", this.connect.connectStatus);
+    this.logger.info("hangup", {
+      caller: "CallKit.hangup",
+      content: {
+        connectStatus: this.connect.connectStatus
+      }
+    });
     if (!this.connect.isConnecting() && !this.connect.isRinging() && !this.connect.isCalling() && !this.connect.isHolding()) {
-      this.logger.warn("Currently not in a call");
+      this.logger.warn("Currently not in a call", {
+        caller: "CallKit.hangup",
+        content: {
+          connectStatus: this.connect.connectStatus
+        }
+      });
       return;
     }
     await this.callCenter.callEnd(true);
@@ -2450,51 +2456,58 @@ var CallKit = class {
   hold() {
     if (!this.config.check())
       return;
-    this.logger.debug("hold");
+    this.logger.info("hold", {
+      caller: "CallKit.hold",
+      content: {
+        connectStatus: this.connect.connectStatus
+      }
+    });
     this.callCenter.callHold();
   }
   unhold() {
     if (!this.config.check())
       return;
-    this.logger.debug("unhold");
+    this.logger.info("unhold", {
+      caller: "CallKit.unhold",
+      content: {
+        connectStatus: this.connect.connectStatus
+      }
+    });
     this.callCenter.callUnhold();
   }
-  async setFree() {
-    if (!this.config.check())
-      return;
-    this.logger.debug("setFree");
-    await this.user.setUserStatus(UserStatus.online);
-  }
-  async setSleep() {
-    if (!this.config.check())
-      return;
-    this.logger.debug("setSleep");
-    await this.user.setUserStatus(UserStatus.catNap);
-  }
-  async setBusy() {
-    if (!this.config.check())
-      return;
-    this.logger.debug("setBusy");
-    await this.user.setUserStatus(UserStatus.busy);
+  /**
+   * set userstatus
+   * @param status
+   */
+  setUserStatus(status) {
+    const { agentId } = this.config.getConfig().userInfo;
+    this.api.updateUserStatus({
+      agentId,
+      status
+    });
   }
   async reset() {
-    this.logger.debug("reset");
+    this.logger.info("reset", {
+      caller: "CallKit.reset",
+      content: {
+        connectStatus: this.connect.connectStatus
+      }
+    });
     this.connect.reset();
-    if (this.config.isLogin()) {
-      await this.user.setUserStatus(UserStatus.online);
-    } else {
-      await this.user.setUserStatus(UserStatus.offline);
-    }
   }
   on(event, callback) {
-    this.logger.debug(`on ${event}`);
     this.listener.push({
       event,
       callback
     });
   }
   off(event, callback) {
-    this.logger.debug(`off ${event}`);
+    this.logger.info(`off ${event}`, {
+      caller: "CallKit.off",
+      content: {
+        event
+      }
+    });
     if (callback) {
       this.listener = this.listener.filter(
         (item) => !(item.event === event && item.callback === callback)
@@ -2505,10 +2518,14 @@ var CallKit = class {
   }
   removeAllListeners() {
     this.listener = this.listener.splice(0, this.listener.length);
-    this.logger.debug("removeAllListeners");
+    this.logger.info("removeAllListeners", {
+      caller: "CallKit.removeAllListeners",
+      content: {
+        listener: this.listener
+      }
+    });
   }
   trigger(event, data) {
-    this.logger.debug(`trigger ${event}`, { data });
     this.listener.forEach((item) => {
       if (item.event === event) {
         try {