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

package/dist/index.global.js

@@ -1083,16 +1083,16 @@ var WebCall = (() => {
         createDebug.names = [];
         createDebug.skips = [];
         createDebug.formatters = {};
-        function selectColor(namespace) {
+        function selectColor(namespace2) {
           let hash = 0;
-          for (let i = 0; i < namespace.length; i++) {
-            hash = (hash << 5) - hash + namespace.charCodeAt(i);
+          for (let i = 0; i < namespace2.length; i++) {
+            hash = (hash << 5) - hash + namespace2.charCodeAt(i);
             hash |= 0;
           }
           return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
         }
         createDebug.selectColor = selectColor;
-        function createDebug(namespace) {
+        function createDebug(namespace2) {
           let prevTime;
           let enableOverride = null;
           let namespacesCache;
@@ -1131,9 +1131,9 @@ var WebCall = (() => {
             const logFn = self.log || createDebug.log;
             logFn.apply(self, args);
           }
-          debug.namespace = namespace;
+          debug.namespace = namespace2;
           debug.useColors = createDebug.useColors();
-          debug.color = createDebug.selectColor(namespace);
+          debug.color = createDebug.selectColor(namespace2);
           debug.extend = extend;
           debug.destroy = createDebug.destroy;
           Object.defineProperty(debug, "enabled", {
@@ -1145,7 +1145,7 @@ var WebCall = (() => {
               }
               if (namespacesCache !== createDebug.namespaces) {
                 namespacesCache = createDebug.namespaces;
-                enabledCache = createDebug.enabled(namespace);
+                enabledCache = createDebug.enabled(namespace2);
               }
               return enabledCache;
             },
@@ -1158,8 +1158,8 @@ var WebCall = (() => {
           }
           return debug;
         }
-        function extend(namespace, delimiter) {
-          const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        function extend(namespace2, delimiter) {
+          const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace2);
           newDebug.log = this.log;
           return newDebug;
         }
@@ -1208,7 +1208,7 @@ var WebCall = (() => {
         function disable() {
           const namespaces = [
             ...createDebug.names,
-            ...createDebug.skips.map((namespace) => "-" + namespace)
+            ...createDebug.skips.map((namespace2) => "-" + namespace2)
           ].join(",");
           createDebug.enable("");
           return namespaces;
@@ -3128,29 +3128,29 @@ var WebCall = (() => {
       var Axios = require_Axios();
       var mergeConfig = require_mergeConfig();
       var defaults = require_defaults();
-      function createInstance(defaultConfig2) {
-        var context = new Axios(defaultConfig2);
+      function createInstance(defaultConfig) {
+        var context = new Axios(defaultConfig);
         var instance2 = bind(Axios.prototype.request, context);
         utils.extend(instance2, Axios.prototype, context);
         utils.extend(instance2, context);
         instance2.create = function create(instanceConfig) {
-          return createInstance(mergeConfig(defaultConfig2, instanceConfig));
+          return createInstance(mergeConfig(defaultConfig, instanceConfig));
         };
         return instance2;
       }
-      var axios3 = createInstance(defaults);
-      axios3.Axios = Axios;
-      axios3.Cancel = require_Cancel();
-      axios3.CancelToken = require_CancelToken();
-      axios3.isCancel = require_isCancel();
-      axios3.VERSION = require_data().version;
-      axios3.all = function all(promises) {
+      var axios2 = createInstance(defaults);
+      axios2.Axios = Axios;
+      axios2.Cancel = require_Cancel();
+      axios2.CancelToken = require_CancelToken();
+      axios2.isCancel = require_isCancel();
+      axios2.VERSION = require_data().version;
+      axios2.all = function all(promises) {
         return Promise.all(promises);
       };
-      axios3.spread = require_spread();
-      axios3.isAxiosError = require_isAxiosError();
-      module.exports = axios3;
-      module.exports.default = axios3;
+      axios2.spread = require_spread();
+      axios2.isAxiosError = require_isAxiosError();
+      module.exports = axios2;
+      module.exports.default = axios2;
     }
   });
 
@@ -3161,6 +3161,78 @@ var WebCall = (() => {
     }
   });
 
+  // node_modules/.pnpm/is-retry-allowed@2.2.0/node_modules/is-retry-allowed/index.js
+  var require_is_retry_allowed = __commonJS({
+    "node_modules/.pnpm/is-retry-allowed@2.2.0/node_modules/is-retry-allowed/index.js"(exports, module) {
+      "use strict";
+      var denyList = /* @__PURE__ */ new Set([
+        "ENOTFOUND",
+        "ENETUNREACH",
+        // SSL errors from https://github.com/nodejs/node/blob/fc8e3e2cdc521978351de257030db0076d79e0ab/src/crypto/crypto_common.cc#L301-L328
+        "UNABLE_TO_GET_ISSUER_CERT",
+        "UNABLE_TO_GET_CRL",
+        "UNABLE_TO_DECRYPT_CERT_SIGNATURE",
+        "UNABLE_TO_DECRYPT_CRL_SIGNATURE",
+        "UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY",
+        "CERT_SIGNATURE_FAILURE",
+        "CRL_SIGNATURE_FAILURE",
+        "CERT_NOT_YET_VALID",
+        "CERT_HAS_EXPIRED",
+        "CRL_NOT_YET_VALID",
+        "CRL_HAS_EXPIRED",
+        "ERROR_IN_CERT_NOT_BEFORE_FIELD",
+        "ERROR_IN_CERT_NOT_AFTER_FIELD",
+        "ERROR_IN_CRL_LAST_UPDATE_FIELD",
+        "ERROR_IN_CRL_NEXT_UPDATE_FIELD",
+        "OUT_OF_MEM",
+        "DEPTH_ZERO_SELF_SIGNED_CERT",
+        "SELF_SIGNED_CERT_IN_CHAIN",
+        "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+        "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+        "CERT_CHAIN_TOO_LONG",
+        "CERT_REVOKED",
+        "INVALID_CA",
+        "PATH_LENGTH_EXCEEDED",
+        "INVALID_PURPOSE",
+        "CERT_UNTRUSTED",
+        "CERT_REJECTED",
+        "HOSTNAME_MISMATCH"
+      ]);
+      module.exports = (error) => !denyList.has(error && error.code);
+    }
+  });
+
+  // node_modules/.pnpm/json-stringify-safe@5.0.1/node_modules/json-stringify-safe/stringify.js
+  var require_stringify = __commonJS({
+    "node_modules/.pnpm/json-stringify-safe@5.0.1/node_modules/json-stringify-safe/stringify.js"(exports, module) {
+      exports = module.exports = stringify2;
+      exports.getSerialize = serializer;
+      function stringify2(obj, replacer, spaces, cycleReplacer) {
+        return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces);
+      }
+      function serializer(replacer, cycleReplacer) {
+        var stack = [], keys = [];
+        if (cycleReplacer == null)
+          cycleReplacer = function(key, value) {
+            if (stack[0] === value)
+              return "[Circular ~]";
+            return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
+          };
+        return function(key, value) {
+          if (stack.length > 0) {
+            var thisPos = stack.indexOf(this);
+            ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
+            ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
+            if (~stack.indexOf(value))
+              value = cycleReplacer.call(this, key, value);
+          } else
+            stack.push(value);
+          return replacer == null ? value : replacer.call(this, key, value);
+        };
+      }
+    }
+  });
+
   // package/index.ts
   var package_exports = {};
   __export(package_exports, {
@@ -3170,94 +3242,218 @@ var WebCall = (() => {
 
   // package/axios.ts
   var import_axios = __toESM(require_axios2());
-  var instance = import_axios.default.create({
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    }
-  });
-  instance.interceptors.request.use((config) => config);
-  instance.interceptors.response.use(
-    (response) => response.data,
-    (error) => Promise.reject(error)
-  );
-  var request = (config) => instance.request(config);
-  var axios_default = request;
 
-  // package/api.ts
-  var Api = class {
-    callKit;
-    constructor(callKit) {
-      this.callKit = callKit;
+  // node_modules/.pnpm/axios-retry@4.5.0_axios@0.26.1/node_modules/axios-retry/dist/esm/index.js
+  var import_is_retry_allowed = __toESM(require_is_retry_allowed(), 1);
+  var namespace = "axios-retry";
+  function isNetworkError(error) {
+    const CODE_EXCLUDE_LIST = ["ERR_CANCELED", "ECONNABORTED"];
+    if (error.response) {
+      return false;
     }
-    async login(params) {
-      return this.post({
-        url: "/auth/agentUser/login",
-        method: "post",
-        data: params
-      });
+    if (!error.code) {
+      return false;
     }
-    async loginOut(params) {
-      return this.post({
-        url: "/auth/agentUser/loginOut",
-        method: "post",
-        data: params
-      });
+    if (CODE_EXCLUDE_LIST.includes(error.code)) {
+      return false;
     }
-    /**
-     *
-     * @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
-      });
+    return (0, import_is_retry_allowed.default)(error);
+  }
+  var SAFE_HTTP_METHODS = ["get", "head", "options"];
+  var IDEMPOTENT_HTTP_METHODS = SAFE_HTTP_METHODS.concat(["put", "delete"]);
+  function isRetryableError(error) {
+    return error.code !== "ECONNABORTED" && (!error.response || error.response.status === 429 || error.response.status >= 500 && error.response.status <= 599);
+  }
+  function isSafeRequestError(error) {
+    if (!error.config?.method) {
+      return false;
     }
-    async measureRTT(config) {
-      this.callKit.logger.debug(`Request ${config.url}:`, config.data);
-      return axios_default(config);
+    return isRetryableError(error) && SAFE_HTTP_METHODS.indexOf(error.config.method) !== -1;
+  }
+  function isIdempotentRequestError(error) {
+    if (!error.config?.method) {
+      return false;
     }
-    async post(config) {
-      this.callKit.logger.debug(`Request ${config.url}:`, config.data);
-      const { userInfo, host } = this.callKit.config.getConfig();
-      const { sessionId } = userInfo;
-      config.url = `${host}${config.url}`;
-      config.headers = {
-        ...config.headers,
-        "Content-Type": "application/x-www-form-urlencoded"
+    return isRetryableError(error) && IDEMPOTENT_HTTP_METHODS.indexOf(error.config.method) !== -1;
+  }
+  function isNetworkOrIdempotentRequestError(error) {
+    return isNetworkError(error) || isIdempotentRequestError(error);
+  }
+  function retryAfter(error = void 0) {
+    const retryAfterHeader = error?.response?.headers["retry-after"];
+    if (!retryAfterHeader) {
+      return 0;
+    }
+    let retryAfterMs = (Number(retryAfterHeader) || 0) * 1e3;
+    if (retryAfterMs === 0) {
+      retryAfterMs = (new Date(retryAfterHeader).valueOf() || 0) - Date.now();
+    }
+    return Math.max(0, retryAfterMs);
+  }
+  function noDelay(_retryNumber = 0, error = void 0) {
+    return Math.max(0, retryAfter(error));
+  }
+  function exponentialDelay(retryNumber = 0, error = void 0, delayFactor = 100) {
+    const calculatedDelay = 2 ** retryNumber * delayFactor;
+    const delay = Math.max(calculatedDelay, retryAfter(error));
+    const randomSum = delay * 0.2 * Math.random();
+    return delay + randomSum;
+  }
+  function linearDelay(delayFactor = 100) {
+    return (retryNumber = 0, error = void 0) => {
+      const delay = retryNumber * delayFactor;
+      return Math.max(delay, retryAfter(error));
+    };
+  }
+  var DEFAULT_OPTIONS = {
+    retries: 3,
+    retryCondition: isNetworkOrIdempotentRequestError,
+    retryDelay: noDelay,
+    shouldResetTimeout: false,
+    onRetry: () => {
+    },
+    onMaxRetryTimesExceeded: () => {
+    },
+    validateResponse: null
+  };
+  function getRequestOptions(config, defaultOptions) {
+    return { ...DEFAULT_OPTIONS, ...defaultOptions, ...config[namespace] };
+  }
+  function setCurrentState(config, defaultOptions, resetLastRequestTime = false) {
+    const currentState = getRequestOptions(config, defaultOptions || {});
+    currentState.retryCount = currentState.retryCount || 0;
+    if (!currentState.lastRequestTime || resetLastRequestTime) {
+      currentState.lastRequestTime = Date.now();
+    }
+    config[namespace] = currentState;
+    return currentState;
+  }
+  function fixConfig(axiosInstance, config) {
+    if (axiosInstance.defaults.agent === config.agent) {
+      delete config.agent;
+    }
+    if (axiosInstance.defaults.httpAgent === config.httpAgent) {
+      delete config.httpAgent;
+    }
+    if (axiosInstance.defaults.httpsAgent === config.httpsAgent) {
+      delete config.httpsAgent;
+    }
+  }
+  async function shouldRetry(currentState, error) {
+    const { retries, retryCondition } = currentState;
+    const shouldRetryOrPromise = (currentState.retryCount || 0) < retries && retryCondition(error);
+    if (typeof shouldRetryOrPromise === "object") {
+      try {
+        const shouldRetryPromiseResult = await shouldRetryOrPromise;
+        return shouldRetryPromiseResult !== false;
+      } catch (_err) {
+        return false;
+      }
+    }
+    return shouldRetryOrPromise;
+  }
+  async function handleRetry(axiosInstance, currentState, error, config) {
+    currentState.retryCount += 1;
+    const { retryDelay, shouldResetTimeout, onRetry } = currentState;
+    const delay = retryDelay(currentState.retryCount, error);
+    fixConfig(axiosInstance, config);
+    if (!shouldResetTimeout && config.timeout && currentState.lastRequestTime) {
+      const lastRequestDuration = Date.now() - currentState.lastRequestTime;
+      const timeout = config.timeout - lastRequestDuration - delay;
+      if (timeout <= 0) {
+        return Promise.reject(error);
+      }
+      config.timeout = timeout;
+    }
+    config.transformRequest = [(data) => data];
+    await onRetry(currentState.retryCount, error, config);
+    if (config.signal?.aborted) {
+      return Promise.resolve(axiosInstance(config));
+    }
+    return new Promise((resolve) => {
+      const abortListener = () => {
+        clearTimeout(timeout);
+        resolve(axiosInstance(config));
       };
-      if (config.headers["Content-Type"] === "application/x-www-form-urlencoded") {
-        config.data = new URLSearchParams(config.data).toString();
+      const timeout = setTimeout(() => {
+        resolve(axiosInstance(config));
+        if (config.signal?.removeEventListener) {
+          config.signal.removeEventListener("abort", abortListener);
+        }
+      }, delay);
+      if (config.signal?.addEventListener) {
+        config.signal.addEventListener("abort", abortListener, { once: true });
       }
-      if (sessionId) {
-        config.headers.sessionId = sessionId;
+    });
+  }
+  async function handleMaxRetryTimesExceeded(currentState, error) {
+    if (currentState.retryCount >= currentState.retries)
+      await currentState.onMaxRetryTimesExceeded(error, currentState.retryCount);
+  }
+  var axiosRetry = (axiosInstance, defaultOptions) => {
+    const requestInterceptorId = axiosInstance.interceptors.request.use((config) => {
+      setCurrentState(config, defaultOptions, true);
+      if (config[namespace]?.validateResponse) {
+        config.validateStatus = () => false;
       }
-      const res = await axios_default(config).catch(() => {
-        this.callKit.config.reset();
-      });
-      if (!res) {
-        this.callKit.config.reset();
-        throw new Error("Network error");
+      return config;
+    });
+    const responseInterceptorId = axiosInstance.interceptors.response.use(null, async (error) => {
+      const { config } = error;
+      if (!config) {
+        return Promise.reject(error);
       }
-      const { code, data, message } = res;
-      if (code === "000000") {
-        return data;
+      const currentState = setCurrentState(config, defaultOptions);
+      if (error.response && currentState.validateResponse?.(error.response)) {
+        return error.response;
       }
-      if (code === "100013") {
-        this.callKit.config.reset();
+      if (await shouldRetry(currentState, error)) {
+        return handleRetry(axiosInstance, currentState, error, config);
       }
-      throw new Error(message ?? "Request failed");
-    }
-    async get(config) {
-      return this.post({
-        ...config,
-        method: "get"
-      });
-    }
+      await handleMaxRetryTimesExceeded(currentState, error);
+      return Promise.reject(error);
+    });
+    return { requestInterceptorId, responseInterceptorId };
   };
+  axiosRetry.isNetworkError = isNetworkError;
+  axiosRetry.isSafeRequestError = isSafeRequestError;
+  axiosRetry.isIdempotentRequestError = isIdempotentRequestError;
+  axiosRetry.isNetworkOrIdempotentRequestError = isNetworkOrIdempotentRequestError;
+  axiosRetry.exponentialDelay = exponentialDelay;
+  axiosRetry.linearDelay = linearDelay;
+  axiosRetry.isRetryableError = isRetryableError;
+  var esm_default = axiosRetry;
+
+  // package/axios.ts
+  var instance = import_axios.default.create({
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    }
+  });
+  instance.interceptors.request.use((config) => config);
+  instance.interceptors.response.use(
+    (response) => response.data,
+    (error) => Promise.reject(error)
+  );
+  esm_default(instance, {
+    retries: 3,
+    // Maximum number of retries, default is 3
+    retryDelay: (retryCount, error) => {
+      console.log(
+        `AJAX Retrying attempt ${retryCount}, error: ${error?.message}`
+      );
+      return retryCount * 1e3;
+    },
+    retryCondition: (error) => {
+      if (!error.response)
+        return true;
+      return error.response.status < 200 || error.response.status >= 300;
+    },
+    shouldResetTimeout: true
+    // Whether to reset axios timeout on retry
+  });
+  var request = (config) => instance.request(config);
+  var axios_default = request;
 
   // package/const.ts
   var UserStatus = {
@@ -3345,6 +3541,10 @@ var WebCall = (() => {
      * Server initiated call
      */
     KIT_INVITE: "invite",
+    /**
+     * Server outgoing initiated call
+     */
+    KIT_OUTGOING_INVITE: "outgoingInvite",
     // /**
     //  * Referral
     //  */
@@ -3389,14 +3589,10 @@ var WebCall = (() => {
      * User status change
      */
     USER_STATUS_CHANGE: "userStatusChange",
-    /**
-     * SOCKET CONNECT EVENT
-     */
     CONNECT_EVENT: "CONNECT_EVENT",
-    /**
-     * NETWORK EVENT
-     */
-    NETWORK_EVENT: "NETWORK_EVENT"
+    SIP_REGISTERER_EVENT: "sipRegistererEvent",
+    SIP_SESSION_EVENT: "sipSessionEvent",
+    USER_STATUS_CHANGE_STEP: "userStatusChangeStep"
   };
   var ErrorCode = {
     /**
@@ -3531,7 +3727,9 @@ var WebCall = (() => {
     /**
      * AGENT_TRANSFER
      */
-    HANG_UP_REASON: "HANG_UP_REASON"
+    HANG_UP_REASON: "HANG_UP_REASON",
+    ACK: "ACK",
+    SDK_LOG: "SDK_LOG"
   };
   var SocketReceiveEvent = {
     /**
@@ -3595,6 +3793,10 @@ var WebCall = (() => {
     NONE: "NONE",
     INTERNAL: "INTERNAL"
   };
+  var LogGatherEnum = {
+    ENABLE: 1,
+    DISABLE: 2
+  };
   var constrainsDefault = {
     audio: {
       autoGainControl: true,
@@ -3612,19 +3814,330 @@ var WebCall = (() => {
   };
   var ConnectEvent = {
     SIP_CONNECT_ERROR: "SIP_CONNECT_ERROR",
+    SIP_RECONNECT_START: "SIP_RECONNECT_START",
     SIP_RECONNECT_ERROR: "SIP_RECONNECT_ERROR",
     SIP_RECONNECT_SUCCESS: "SIP_RECONNECT_SUCCESS",
+    SIP_RECONNECTING: "SIP_RECONNECTING",
+    INCALL_NOT_CONNECTED: "INCALL_NOT_CONNECTED",
     INCALL_CONNECT_ERROR: "INCALL_CONNECT_ERROR",
+    INCALL_RECONNECT_START: "INCALL_RECONNECT_START",
     INCALL_RECONNECT_ERROR: "INCALL_RECONNECT_ERROR",
     INCALL_RECONNECT_SUCCESS: "INCALL_RECONNECT_SUCCESS",
+    INCALL_RECONNECTING: "INCALL_RECONNECTING",
     OPTIONS_HEARTBEAT_EXPIRED: "OPTIONS_HEARTBEAT_EXPIRED",
-    USER_AGENT_START_ERROR: "USER_AGENT_START_ERROR",
-    CONNECT_CLOSING: "CONNECT_CLOSING",
-    CONNECT_CLOSING_END: "CONNECT_CLOSING_END"
+    USER_AGENT_START_ERROR: "USER_AGENT_START_ERROR"
+  };
+  var SipRegistererEvent = {
+    Initial: "Initial",
+    Registered: "Registered",
+    Unregistered: "Unregistered",
+    Terminated: "Terminated"
+  };
+  var SipSessionEvent = {
+    Establishing: "Establishing",
+    Established: "Established",
+    Terminating: "Terminating",
+    Terminated: "Terminated"
   };
-  var NetWorkEvent = {
-    RTT_MEASURE_SUCCESS: "RTT_MEASURE_SUCCESS",
-    RTT_MEASURE_FAILED: "RTT_MEASURE_FAILED"
+  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_stringify());
+  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
@@ -3668,12 +4181,6 @@ var WebCall = (() => {
       if (!this.callKit.config.check())
         return;
       this.callKit.logger.debug("callRefer");
-      const { toAgentId, workOrderId } = options;
-      const queryTrain = {
-        toAgentId,
-        workOrderId
-      };
-      this.callKit.socket.send(SocketSendEvent.AGENT_TRANSFER, queryTrain);
       this.callKit.connect.refer(referTo, options);
     }
     /**
@@ -3720,7 +4227,7 @@ var WebCall = (() => {
       this.callKit = callKit;
     }
     config = {
-      version: "1.0.2",
+      version: "1.0.24-beta.30",
       host: "",
       log: "debug",
       audioRef: void 0,
@@ -3746,7 +4253,8 @@ var WebCall = (() => {
         fsPort: "",
         iceInfo: [],
         iceGatheringTimeout: 0,
-        encryptionMethod: EncryptionMethod.INTERNAL
+        encryptionMethod: EncryptionMethod.INTERNAL,
+        logGather: LogGatherEnum.DISABLE
       },
       // EXECUTE setUserStatus
       isAutoUpdateUserStatus: true
@@ -3778,7 +4286,8 @@ var WebCall = (() => {
           fsPort: "",
           iceInfo: [],
           iceGatheringTimeout: this.config.userInfo.iceGatheringTimeout,
-          encryptionMethod: EncryptionMethod.INTERNAL
+          encryptionMethod: EncryptionMethod.INTERNAL,
+          logGather: LogGatherEnum.DISABLE
         };
         this.callKit.trigger(KitEvent.KIT_LOGIN_CHANGE, false);
       }
@@ -3791,6 +4300,7 @@ var WebCall = (() => {
       return true;
     };
     isLogin = () => this.validate();
+    isLogGatherEnable = () => this.config.userInfo.logGather === LogGatherEnum.ENABLE;
     check() {
       if (!this.isLogin()) {
         this.callKit.logger.error("User not logged in", {
@@ -3802,78 +4312,6 @@ var WebCall = (() => {
     }
   };
 
-  // package/logger.ts
-  function getLevel(level) {
-    return LoggerLevelMap[level];
-  }
-  var Logger = class {
-    prefix = "CallKit";
-    level = "debug";
-    callKit;
-    constructor(callKit, level) {
-      this.callKit = callKit;
-      this.level = level || "debug";
-    }
-    setLevel(level) {
-      this.level = level;
-    }
-    debug(msg, extra) {
-      if (getLevel(this.level) >= getLevel("debug")) {
-        this.output("blue")(msg, extra);
-      }
-    }
-    log(msg, extra) {
-      if (getLevel(this.level) >= getLevel("log")) {
-        this.output("green")(msg, extra);
-      }
-    }
-    warn(msg, extra) {
-      if (getLevel(this.level) >= getLevel("warn")) {
-        this.output("orange")(msg, extra);
-      }
-    }
-    error(msg, extra) {
-      const message = msg?.message ?? msg;
-      if (getLevel(this.level) >= getLevel("error")) {
-        this.output("red")(message, extra);
-      }
-      const { errCode, ...rest } = extra;
-      const errorCode = errCode ?? ErrorCode.UNKNOWN_ERROR;
-      this.callKit.trigger(KitEvent.KIT_ERROR, {
-        code: errorCode,
-        msg: message,
-        data: rest
-      });
-      this.callKit.reset();
-      const error = new Error(message);
-      error.name = "CallKitError";
-      error.code = errorCode;
-      error.data = rest;
-      throw error;
-    }
-    output(color) {
-      return (msg, extra = {}) => {
-        const now = /* @__PURE__ */ new Date();
-        if (Object.keys(extra).length > 0) {
-          console.log(
-            `%c[${this.prefix}] %c ${msg} %o %c ${now.toLocaleString()}`,
-            `color: ${color};`,
-            "color:block;",
-            extra,
-            "color:#999;"
-          );
-        } else {
-          console.log(
-            `%c[${this.prefix}] %c ${msg} %c ${now.toLocaleString()}`,
-            `color: ${color};`,
-            "color:block;",
-            "color:#999;"
-          );
-        }
-      };
-    }
-  };
-
   // node_modules/.pnpm/sip.js@0.21.2/node_modules/sip.js/lib/version.js
   var LIBRARY_VERSION = "0.21.1";
 
@@ -12875,8 +13313,8 @@ var WebCall = (() => {
           this.logger.warn(msg);
           return;
         };
-        const retryAfter = Math.floor(Math.random() * 10) + 1;
-        const extraHeaders = [`Retry-After: ${retryAfter}`];
+        const retryAfter2 = Math.floor(Math.random() * 10) + 1;
+        const extraHeaders = [`Retry-After: ${retryAfter2}`];
         if (this.ackProcessing) {
           this.core.replyStateless(message, { statusCode: 500, extraHeaders });
           warning();
@@ -18297,7 +18735,9 @@ var WebCall = (() => {
         const getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia;
         if (!getUserMedia) {
           return Promise.reject(
-            new Error("Browser version is too low, please upgrade and try again.")
+            new Error(
+              "Unable to obtain device permissions. Please check your browser settings or device permissions."
+            )
           );
         }
         return new Promise((resolve, reject) => {
@@ -18318,7 +18758,7 @@ var WebCall = (() => {
     registerer;
     lastOptionsUpdateTime = 0;
     observeOptionsHeartbeatHandler = null;
-    sipConnected = false;
+    // sipConnected = false;
     /**
      * Whether it's an outgoing call
      */
@@ -18327,6 +18767,7 @@ var WebCall = (() => {
      * Whether it's an active hangup
      */
     isUnprompted = false;
+    isCurrentSessionInvited = false;
     reconnectConfig;
     /**
      * Whether registered
@@ -18366,7 +18807,6 @@ var WebCall = (() => {
       this.registerer = void 0;
       this.isOutgoing = false;
       this.isUnprompted = false;
-      this.sipConnected = false;
       this.clearObserveOptionsHeartbeatInterval();
       if (this.isHold) {
         this.setHoldStatus(false);
@@ -18380,7 +18820,7 @@ var WebCall = (() => {
       return audioRef;
     }
     async permission() {
-      this.callKit.logger.debug("permission");
+      this.callKit.logger.debug("ssion");
       initUserMedia();
       const _stream = await navigator.mediaDevices.getUserMedia({ audio: true });
       closeStream(_stream);
@@ -18427,6 +18867,9 @@ var WebCall = (() => {
     isInit() {
       return this.connectStatus === CallStatus.init;
     }
+    isExecuting() {
+      return this.callKit.user.getUserChangeStatusExecuting();
+    }
     clearObserveOptionsHeartbeatInterval() {
       if (this.observeOptionsHeartbeatHandler !== null) {
         clearInterval(this.observeOptionsHeartbeatHandler);
@@ -18506,13 +18949,18 @@ var WebCall = (() => {
         that.userAgent.transport.onDisconnect = (error) => {
           if (error) {
             that.callKit.logger.debug("connect onDisconnect");
-            if (that.isRegistered() && !(that.sipConnected || that.isRinging() || that.isCalling() || that.isHolding())) {
+            if (that.isRegistered() && !// that.sipConnected ||
+            (that.isRinging() || that.isCalling() || that.isHolding())) {
               that.reconnect();
             } else {
               that.callKit.logger.debug("SIP WebSocket closed with error", {
                 event: ConnectEvent.SIP_CONNECT_ERROR,
                 err: error
               });
+              that.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
+                event: ConnectEvent.SIP_CONNECT_ERROR,
+                err: error
+              });
               that.callKit.trigger(KitEvent.CONNECT_EVENT, {
                 event: ConnectEvent.SIP_CONNECT_ERROR,
                 err: error
@@ -18528,7 +18976,7 @@ var WebCall = (() => {
           }
         };
         that.clearObserveOptionsHeartbeatInterval();
-        setInterval(() => {
+        that.observeOptionsHeartbeatHandler = setInterval(() => {
           if (that.lastOptionsUpdateTime !== 0) {
             const now = (/* @__PURE__ */ new Date()).getTime();
             const diff = now - that.lastOptionsUpdateTime;
@@ -18543,6 +18991,11 @@ var WebCall = (() => {
                 lastOptionsUpdateTime: that.lastOptionsUpdateTime,
                 now
               });
+              that.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
+                event: ConnectEvent.OPTIONS_HEARTBEAT_EXPIRED,
+                lastOptionsUpdateTime: that.lastOptionsUpdateTime,
+                now
+              });
               that.clearObserveOptionsHeartbeatInterval();
             }
           }
@@ -18554,38 +19007,118 @@ var WebCall = (() => {
           if (request2.method === "OPTIONS") {
             that.lastOptionsUpdateTime = (/* @__PURE__ */ new Date()).getTime();
           }
+          that.callKit.logger.addLogData(LogDataEnum.SIP, request2);
           return originalReceiveRequest(request2);
         };
       };
       const registererOptions = {};
       this.registerer = new Registerer(this.userAgent, registererOptions);
+      this.registerer.stateChange.addListener((state) => {
+        switch (state) {
+          case RegistererState.Initial:
+            this.callKit.logger.debug("registerer stateChange Initial");
+            this.setRegister(false);
+            this.setConnectStatus(CallStatus.init);
+            this.callKit.user.setUserStatus(UserStatus.offline);
+            this.callKit.trigger(
+              KitEvent.SIP_REGISTERER_EVENT,
+              SipRegistererEvent.Initial
+            );
+            break;
+          case RegistererState.Registered:
+            this.callKit.logger.debug("registerer stateChange Registered");
+            this.setRegister(true);
+            this.setConnectStatus(CallStatus.registered);
+            this.callKit.user.setUserStatus(UserStatus.online);
+            this.callKit.trigger(
+              KitEvent.SIP_REGISTERER_EVENT,
+              SipRegistererEvent.Registered
+            );
+            break;
+          case RegistererState.Terminated:
+            this.callKit.logger.debug("registerer stateChange Terminated");
+            this.setRegister(false);
+            this.setConnectStatus(CallStatus.init);
+            this.callKit.user.setUserStatus(UserStatus.offline);
+            this.callKit.trigger(
+              KitEvent.SIP_REGISTERER_EVENT,
+              SipRegistererEvent.Terminated
+            );
+            break;
+          case RegistererState.Unregistered:
+            this.callKit.logger.debug("registerer stateChange Unregistered");
+            this.setRegister(false);
+            this.setConnectStatus(CallStatus.init);
+            this.callKit.user.setUserStatus(UserStatus.offline);
+            this.callKit.trigger(
+              KitEvent.SIP_REGISTERER_EVENT,
+              SipRegistererEvent.Unregistered
+            );
+            break;
+          default:
+            break;
+        }
+      });
       this.userAgent.delegate = {
         onInvite: (invite) => {
           this.callKit.logger.debug("connect onInvite");
           this.currentSession = invite;
+          if (this.isOutgoing) {
+            this.isCurrentSessionInvited = false;
+          }
           this.currentSession.stateChange.addListener((state) => {
+            const isExecuting = this.isExecuting();
             switch (state) {
               case SessionState2.Establishing:
                 this.callKit.logger.debug("connect Establishing");
+                this.setConnectStatus(CallStatus.ringing);
+                if (!isExecuting) {
+                  this.callKit.user.setUserStatus(UserStatus.busy);
+                  this.callKit.trigger(
+                    KitEvent.SIP_SESSION_EVENT,
+                    SipSessionEvent.Establishing
+                  );
+                }
                 break;
               case SessionState2.Established:
                 this.callKit.logger.debug("connect Established");
-                if (this.connectStatus === CallStatus.registered) {
-                  this.callKit.logger.warn("call is already hangup");
-                  return;
+                this.callKit.connect.setConnectStatus(CallStatus.calling);
+                if (!isExecuting) {
+                  this.callKit.trigger(
+                    KitEvent.SIP_SESSION_EVENT,
+                    SipSessionEvent.Established
+                  );
+                  setupRemoteMedia(this.currentSession);
                 }
-                this.sipConnected = true;
-                setupRemoteMedia(this.currentSession);
                 break;
               case SessionState2.Terminating:
                 this.callKit.logger.debug("connect Terminating");
+                if (!isExecuting) {
+                  this.callKit.trigger(
+                    KitEvent.SIP_SESSION_EVENT,
+                    SipSessionEvent.Terminating
+                  );
+                }
                 break;
               case SessionState2.Terminated:
                 this.callKit.logger.debug("connect Terminated");
                 if (!this.isUnprompted) {
                   this.callKit.callCenter.callEnd();
+                } else if (this.isCalling()) {
+                  if (this.isCurrentSessionInvited) {
+                    this.currentSession.reject();
+                  }
+                  this.callKit.callCenter.callEnd(true, false);
                 }
                 this.isUnprompted = false;
+                if (!isExecuting) {
+                  this.callKit.user.setUserStatus(UserStatus.catNap);
+                  this.setConnectStatus(CallStatus.registered);
+                  this.callKit.trigger(
+                    KitEvent.SIP_SESSION_EVENT,
+                    SipSessionEvent.Terminated
+                  );
+                }
                 break;
               default:
                 break;
@@ -18599,17 +19132,37 @@ var WebCall = (() => {
           };
           if (this.isOutgoing) {
             this.currentSession.accept(options);
+            this.callKit.trigger(KitEvent.KIT_OUTGOING_INVITE, {
+              getInviteData: () => {
+                const { request: request2 } = this.currentSession;
+                const headerNames = Object.keys(request2.headers);
+                const xHeaders = {};
+                headerNames.filter(
+                  (name) => name.toLocaleLowerCase().startsWith("x-antaios")
+                ).forEach((name) => {
+                  xHeaders[name.toLocaleLowerCase()] = request2.getHeader(name);
+                });
+                this.callKit.logger.debug("get invite data", xHeaders);
+                return xHeaders;
+              }
+            });
           } else {
+            const isExecuting = this.isExecuting();
+            const reject = () => {
+              this.currentSession.reject();
+              this.callKit.callCenter.callEnd(true, false);
+            };
+            if (isExecuting) {
+              reject();
+              return;
+            }
             this.callKit.trigger(KitEvent.KIT_INVITE, {
               accept: () => {
-                this.setConnectStatus(CallStatus.connecting);
+                this.isCurrentSessionInvited = true;
                 this.callKit.trigger(KitEvent.CALL_CONNECTING, /* @__PURE__ */ new Date());
                 this.currentSession.accept(options);
               },
-              reject: () => {
-                this.currentSession.reject();
-                this.callKit.callCenter.callEnd(true, false);
-              },
+              reject,
               getInviteData: () => {
                 const { request: request2 } = this.currentSession;
                 const headerNames = Object.keys(request2.headers);
@@ -18627,9 +19180,12 @@ var WebCall = (() => {
         },
         onConnect: async () => {
           this.callKit.logger.debug("connect onConnect");
+          const version = `V${this.callKit.config.getConfig().version}`;
           await this.registerer.register().then(() => {
-            this.callKit.socket.send(SocketSendEvent.START);
-          }).catch((err) => {
+            this.callKit.socket.send(SocketSendEvent.START, {
+              version
+            });
+          }).catch(async (err) => {
             this.callKit.logger.error(err?.message, {
               errCode: ErrorCode.WEBRTC_REGISTER_ERROR
             });
@@ -18637,13 +19193,18 @@ var WebCall = (() => {
         },
         onDisconnect: (error) => {
           this.callKit.logger.debug("connect onDisconnect");
-          if (this.isRegistered() && !(this.sipConnected || this.isRinging() || this.isCalling() || this.isHolding())) {
+          if (this.isRegistered() && !// this.sipConnected ||
+          (this.isRinging() || this.isCalling() || this.isHolding())) {
             this.reconnect();
           } else {
             this.callKit.trigger(KitEvent.CONNECT_EVENT, {
               event: ConnectEvent.SIP_CONNECT_ERROR,
               err: error
             });
+            this.callKit.logger.addLogData(LogDataEnum.ERROR, {
+              event: ConnectEvent.SIP_CONNECT_ERROR,
+              err: error
+            });
             this.callKit.user.sendHangUpReason({
               eventType: ConnectEvent.SIP_RECONNECT_ERROR,
               err: error
@@ -18695,6 +19256,11 @@ var WebCall = (() => {
           return;
         reconnectTimer = setTimeout(async () => {
           try {
+            if (currentRetry === 0) {
+              this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+                event: ConnectEvent.SIP_RECONNECT_START
+              });
+            }
             currentRetry += 1;
             this.callKit.logger.debug(
               `Attempting to reconnect SIP... (Attempt ${currentRetry}/${this.reconnectConfig.maxAttempts})`
@@ -18737,9 +19303,7 @@ var WebCall = (() => {
         this.callKit.logger.warn("No registerer to unregister.");
         return;
       }
-      await this.registerer.unregister({ all: true }).then(() => {
-        this.setConnectStatus(CallStatus.init);
-      }).catch((err) => {
+      await this.registerer.unregister({ all: true }).catch((err) => {
         this.callKit.logger.error(err, {
           errCode: ErrorCode.WEBRTC_CANCEL_REGISTER_ERROR
         });
@@ -18770,12 +19334,6 @@ var WebCall = (() => {
      */
     setConnectStatus(status) {
       this.callKit.logger.debug(`connect setConnectStatus: ${status}`);
-      if (this.isRegistered() && status === CallStatus.init) {
-        this.setRegister(false);
-      }
-      if (!this.isRegistered() && status !== CallStatus.init) {
-        this.setRegister(true);
-      }
       this.connectStatus = status;
       this.callKit.trigger(KitEvent.KIT_CALL_STATUS_CHANGE, status);
     }
@@ -18793,13 +19351,14 @@ var WebCall = (() => {
       this.isUnprompted = isUnprompted;
       try {
         if (isUnprompted) {
-          this.callKit.socket.send(SocketSendEvent.AGENT_HANGUP);
-          const shouldSendBye = this.sipConnected || this.isRinging() || this.isCalling() || this.isHolding();
+          const shouldSendBye = (
+            // this.sipConnected ||
+            this.isRinging() || this.isCalling() || this.isHolding()
+          );
           if (shouldSendBye) {
             await this.currentSession?.bye();
           }
         }
-        this.sipConnected = false;
         closeStream(this.mediaStream);
         const audioRef = this.getAduioReference();
         if (audioRef) {
@@ -18808,8 +19367,6 @@ var WebCall = (() => {
         }
         if (isError) {
           this.setConnectStatus(CallStatus.init);
-        } else {
-          this.setConnectStatus(CallStatus.registered);
         }
         this.callKit.trigger(KitEvent.CALL_END, /* @__PURE__ */ new Date());
       } catch (err) {
@@ -18940,59 +19497,6 @@ var WebCall = (() => {
     }
   };
 
-  // package/monitor.ts
-  var import_axios3 = __toESM(require_axios2());
-  var defaultConfig = {
-    interval: 5e3,
-    apiEndpoint: "/livez"
-  };
-  var Monitor = class {
-    callKit;
-    interval = defaultConfig.interval;
-    apiEndpoint = defaultConfig.apiEndpoint;
-    monitorIntervalHandler = null;
-    constructor(callKit) {
-      this.callKit = callKit;
-      const { monitor } = this.callKit.config.getConfig();
-      this.interval = monitor?.interval ?? defaultConfig.interval;
-      this.apiEndpoint = monitor?.apiEndpoint ?? defaultConfig.apiEndpoint;
-      this.monitorIntervalHandler = null;
-    }
-    getEndPointPath = () => {
-      const config = this.callKit.config.getConfig();
-      const defaultPath = `${config.host}${this.apiEndpoint}`;
-      const endPointPath = config.monitor?.apiEndpoint ?? defaultPath;
-      return endPointPath;
-    };
-    measureRTT = async () => {
-      try {
-        const endPoint = this.getEndPointPath();
-        const startTime = performance.now();
-        await import_axios3.default.get(endPoint);
-        const endTime = performance.now();
-        const rtt = Math.round(endTime - startTime);
-        this.callKit.trigger(KitEvent.NETWORK_EVENT, {
-          event: NetWorkEvent.RTT_MEASURE_SUCCESS,
-          rtt
-        });
-      } catch (error) {
-        this.callKit.trigger(KitEvent.NETWORK_EVENT, {
-          event: NetWorkEvent.RTT_MEASURE_FAILED,
-          rtt: 0
-        });
-      }
-    };
-    stopRTTMonitoring() {
-      if (this.monitorIntervalHandler) {
-        clearInterval(this.monitorIntervalHandler);
-      }
-    }
-    startRTTMonitoring() {
-      this.stopRTTMonitoring();
-      this.monitorIntervalHandler = setInterval(this.measureRTT, this.interval);
-    }
-  };
-
   // package/socket.ts
   var RECONNECT_CONFIG = {
     enabled: true,
@@ -19016,7 +19520,6 @@ var WebCall = (() => {
     reconnectTimer;
     isReconnecting = false;
     reconnectAttempts = 0;
-    closing = false;
     constructor(callKit) {
       this.callKit = callKit;
       const { reconnect } = this.callKit.config.getConfig();
@@ -19030,15 +19533,13 @@ var WebCall = (() => {
       this.callKit.logger.debug(`socket init: ${socket}`);
       this.connect(socket);
     }
-    close(code, reason) {
-      this.ws?.close(code, reason);
-    }
-    gracefulClose() {
-      this.closing = true;
-      this.callKit.trigger(KitEvent.CONNECT_EVENT, {
-        event: ConnectEvent.CONNECT_CLOSING
-      });
-      this.close(1e3, "normal");
+    // confirm from connect startConfirm
+    // startConfirm(status: boolean) {
+    //   this.callKit.logger.debug('register success');
+    //   this.satrtConfirm = status;
+    // }
+    setRecivedClose(status) {
+      this.recivedClose = status;
     }
     reconnect(ev) {
       this.callKit.logger.debug("socket reconnect", ev);
@@ -19048,12 +19549,21 @@ var WebCall = (() => {
           "socket reconnect times",
           this.socketConfig.maxAttempts
         );
+        this.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
+          event: ConnectEvent.INCALL_RECONNECTING,
+          attempts: this.reconnectAttempts,
+          err: ev
+        });
         this.attemptReconnect();
       } else if (this.reconnectAttempts >= this.socketConfig.maxAttempts) {
         this.callKit.trigger(KitEvent.CONNECT_EVENT, {
           event: ConnectEvent.INCALL_RECONNECT_ERROR,
           err: ev
         });
+        this.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
+          event: ConnectEvent.INCALL_RECONNECT_ERROR,
+          err: ev
+        });
         this.reset();
         this.callKit.logger.error(
           "Reconnection failed, maximum retry attempts reached",
@@ -19072,6 +19582,10 @@ var WebCall = (() => {
     }
     onOpen(ev) {
       this.callKit.logger.debug("socket onOpen", ev);
+      this.callKit.logger.addLogData(LogDataEnum.INCALL, {
+        callKitSocketFrom: "onOpen",
+        ev
+      });
       this.isConnected = true;
       this.lastPingTime = Date.now();
       this.checkPing();
@@ -19090,11 +19604,23 @@ var WebCall = (() => {
     }
     onClose(ev) {
       this.callKit.logger.debug("socket onClose", ev);
+      this.callKit.logger.addLogData(LogDataEnum.INCALL, {
+        callKitSocketFrom: "onClose",
+        ev
+      });
       if ((ev.code !== 1e3 || !ev.wasClean) && this.callKit.connect.isRegistered()) {
         this.callKit.trigger(KitEvent.CONNECT_EVENT, {
           event: ConnectEvent.INCALL_CONNECT_ERROR,
           err: ev
         });
+        this.callKit.logger.addLogData(LogDataEnum.ERROR, {
+          event: ConnectEvent.INCALL_CONNECT_ERROR,
+          err: ev
+        });
+        this.callKit.logger.addLogData(LogDataEnum.RECONNECT, {
+          event: ConnectEvent.INCALL_CONNECT_ERROR,
+          err: ev
+        });
         this.reconnect(ev);
       } else {
         this.isConnected = false;
@@ -19105,10 +19631,6 @@ var WebCall = (() => {
         }
         this.callKit.connect.hangup();
         this.reset();
-        this.closing = false;
-        this.callKit.trigger(KitEvent.CONNECT_EVENT, {
-          event: ConnectEvent.CONNECT_CLOSING_END
-        });
       }
     }
     onError(ev) {
@@ -19116,46 +19638,53 @@ var WebCall = (() => {
         errCode: ErrorCode.SOCKET_CONNECT_ERROR,
         data: ev
       });
+      this.callKit.logger.addLogData(LogDataEnum.INCALL, {
+        callKitSocketFrom: "onError",
+        ev
+      });
       if (this.isReconnecting) {
         this.attemptReconnect();
       }
     }
+    confirmAck(data) {
+      const { ack, messageId } = data;
+      if (ack) {
+        this.send(SocketSendEvent.ACK, {
+          messageId
+          // sessionId
+        });
+      }
+    }
     onMessage(ev) {
       const data = JSON.parse(ev.data);
       this.callKit.logger.debug("socket onMessage", data);
+      this.callKit.logger.addLogData(LogDataEnum.INCALL, {
+        callKitSocketFrom: "onMessage",
+        ev
+      });
+      this.confirmAck(data);
       if (data.event === SocketReceiveEvent.PONG) {
         this.lastPingTime = Date.now();
         return;
       }
       if (data.event === SocketReceiveEvent.START_CONFIRM) {
-        this.callKit.logger.debug("register success");
+        this.callKit.logger.debug("start confirm success");
         this.satrtConfirm = true;
-        this.callKit.connect.setConnectStatus(CallStatus.registered);
       }
       if (data.event === SocketReceiveEvent.CALL_SUCCESS) {
         this.recivedClose = false;
-        this.callKit.logger.debug("callStart");
-        this.callKit.user.setUserStatus(UserStatus.busy);
       }
       if (data.event === SocketReceiveEvent.CALL_FAILED) {
         this.callKit.logger.debug(data.msg, {
           errCode: ErrorCode.SOCKET_CALL_ERROR
         });
-        this.callKit.user.setUserStatus(UserStatus.online);
       }
       if (data.event === SocketReceiveEvent.CUSTOMER_RINGING) {
-        this.callKit.logger.debug(data.msg);
-        if (this.callKit.connect.isConnecting()) {
-          this.callKit.trigger(KitEvent.CALL_RINGING, /* @__PURE__ */ new Date());
-          this.callKit.connect.setConnectStatus(CallStatus.ringing);
-        }
+        this.callKit.trigger(KitEvent.CALL_RINGING, /* @__PURE__ */ new Date());
       }
       if (data.event === SocketReceiveEvent.CUSTOMER_PICK_UP) {
         this.callKit.logger.debug(data.msg);
-        if (this.callKit.connect.isRinging()) {
-          this.callKit.connect.setConnectStatus(CallStatus.calling);
-          this.callKit.trigger(KitEvent.CALL_PICK_UP, /* @__PURE__ */ new Date());
-        }
+        this.callKit.trigger(KitEvent.CALL_PICK_UP, /* @__PURE__ */ new Date());
       }
       if (data.event === SocketReceiveEvent.AGENT_PICK_UP) {
         this.callKit.logger.debug(data.msg);
@@ -19164,12 +19693,10 @@ var WebCall = (() => {
       if (data.event === SocketReceiveEvent.CUSTOMER_HANG_UP) {
         this.callKit.logger.debug(data.msg);
         this.callKit.trigger(KitEvent.CALL_HANG_UP, /* @__PURE__ */ new Date());
-        this.callKit.user.setUserStatus(UserStatus.catNap);
       }
       if (data.event === SocketReceiveEvent.CUSTOMER_NO_ANSWER) {
         this.callKit.logger.debug(data.msg);
         this.callKit.trigger(KitEvent.CALL_NO_ANSWER);
-        this.callKit.user.setUserStatus(UserStatus.catNap);
       }
       if (data.event === SocketReceiveEvent.CALL_CDR) {
         this.callKit.logger.debug(data.msg);
@@ -19177,7 +19704,7 @@ var WebCall = (() => {
       }
       if (data.event === SocketReceiveEvent.STOP_CONFIRM) {
         this.callKit.logger.debug(data.msg);
-        this.recivedClose = true;
+        this.setRecivedClose(true);
       }
       if (data.event === SocketReceiveEvent.CLOSE) {
         const { userInfo } = this.callKit.config.getConfig();
@@ -19187,19 +19714,21 @@ var WebCall = (() => {
         });
       }
       if (data.event === SocketReceiveEvent.ERROR) {
-        this.callKit.logger.error(data.msg, {
+        this.callKit.unregister();
+        this.callKit.logger.debug(data.msg, {
           errCode: ErrorCode.SOKET_SERVER_ERROR,
           data
         });
-        this.callKit.user.setUserStatus(UserStatus.catNap);
       }
       if (data.event === SocketReceiveEvent.AGENT_NO_ANSWER) {
-        this.callKit.user.setUserStatus(UserStatus.catNap);
       }
       this.callKit.trigger(KitEvent.SERVER_SOCKET_EVENT, data);
     }
     send(event, message) {
       if (!this.isConnected) {
+        this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+          event: ConnectEvent.INCALL_NOT_CONNECTED
+        });
         this.callKit.logger.error("socket not connected", {
           errCode: ErrorCode.SOCKET_CONNECT_ERROR
         });
@@ -19242,6 +19771,9 @@ var WebCall = (() => {
     }
     async sendMessage(event, message) {
       if (!this.isConnected) {
+        this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+          event: ConnectEvent.INCALL_NOT_CONNECTED
+        });
         this.callKit.logger.error("socket not connected", {
           errCode: ErrorCode.SOCKET_CONNECT_ERROR
         });
@@ -19316,11 +19848,16 @@ var WebCall = (() => {
         }
         this.recivedClose = false;
         this.callKit.logger.debug("socket destroy");
-        this.ws.close(4002, "sdk reset");
+        this.ws.close();
         this.isConnected = false;
       }
     }
     attemptReconnect() {
+      if (this.reconnectAttempts === 0) {
+        this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+          event: ConnectEvent.INCALL_RECONNECT_START
+        });
+      }
       if (this.isReconnecting && this.reconnectAttempts >= this.socketConfig.maxAttempts) {
         this.callKit.trigger(KitEvent.CONNECT_EVENT, {
           event: ConnectEvent.INCALL_RECONNECT_ERROR
@@ -19355,8 +19892,102 @@ var WebCall = (() => {
     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
+        });
+      });
     }
     /**
      *
@@ -19373,24 +20004,70 @@ var WebCall = (() => {
      * @param status
      */
     async updateUserStatus(status) {
-      const { agentId } = this.callKit.config.getConfig().userInfo;
-      if (!this.callKit.config.isLogin()) {
-        this.userStatus = UserStatus.offline;
-        this.callKit.trigger(KitEvent.KIT_USER_STATUS_CHANGE, UserStatus.offline);
+      if (this.userChangeStatusExecuting)
         return;
-      }
-      await this.callKit.api.setUserStatus({
+      const { agentId } = this.callKit.config.getConfig().userInfo;
+      this.setUserChangeStatusExecuting(true);
+      const postData = {
         agentId,
         userStatus: status
-      }).then(() => {
+      };
+      const logData = {
+        postData,
+        url: "/agent/user/changeStatus",
+        status: "send",
+        startTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+        startTime: (/* @__PURE__ */ new Date()).toLocaleString()
+      };
+      this.callKit.logger.addLogData(LogDataEnum.AJAX, logData);
+      this.callKit.trigger(KitEvent.USER_STATUS_CHANGE_STEP, {
+        event: UserStatusChangeStepEnum.UserStatusChangeStart
+      });
+      await this.callKit.api.setUserStatus(postData).then(() => {
+        this.setUserChangeStatusExecuting(false);
         this.userStatus = status;
+        this.callKit.trigger(KitEvent.USER_STATUS_CHANGE_STEP, {
+          event: UserStatusChangeStepEnum.UserStatusChangeEnd
+        });
         this.callKit.trigger(KitEvent.KIT_USER_STATUS_CHANGE, status);
+        this.callKit.logger.addLogData(LogDataEnum.AJAX, {
+          ...logData,
+          status: "success",
+          endTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+          endTime: (/* @__PURE__ */ new Date()).toLocaleString()
+        });
       }).catch((err) => {
+        this.setUserChangeStatusExecuting(false);
+        this.callKit.logger.addLogData(LogDataEnum.AJAX, {
+          ...logData,
+          status: "error",
+          endTimeStamp: (/* @__PURE__ */ new Date()).valueOf(),
+          endTime: (/* @__PURE__ */ new Date()).toLocaleString()
+        });
+        this.callKit.trigger(KitEvent.USER_STATUS_CHANGE_STEP, {
+          event: UserStatusChangeStepEnum.UserStatusChangeError
+        });
+        this.setUserChangeStatusExecuting(false);
+        if (this.callKit.connect.isRegistered()) {
+          this.callKit.unregister();
+        }
+        this.callKit.trigger(
+          KitEvent.KIT_USER_STATUS_CHANGE,
+          UserStatus.offline
+        );
         this.callKit.logger.error(err, {
           errCode: ErrorCode.API_USER_STATUS_UPDATE_ERROR
         });
       });
     }
+    /**
+     * @description sdkLog
+     * @param params
+     * @returns
+     */
+    async sendSdkLog(data) {
+      return this.callKit.api.sdkLog(data);
+    }
     async sendHangUpReason(data) {
       try {
         const sendData = data || {};
@@ -19410,7 +20087,6 @@ var WebCall = (() => {
     connect;
     socket;
     user;
-    monitor;
     listener = [];
     constructor(options) {
       this.config = new Config(this);
@@ -19428,8 +20104,6 @@ var WebCall = (() => {
       );
       this.config.setConfig("reconnect", options.reconnect);
       this.logger = new Logger(this, options.log);
-      this.config.setConfig("monitor", options.monitor);
-      this.monitor = new Monitor(this);
       this.logger.debug("callKit init", options);
       this.api = new Api(this);
       this.connect = new Connect(this);
@@ -19463,11 +20137,9 @@ var WebCall = (() => {
         encryptionMethod,
         encryptionPassword
       });
-      const user = await this.api.login({
+      const user = await this.user.login({
         userName: username,
         password: encryptionPassword
-      }).catch((err) => {
-        this.logger.error(err, { errCode: ErrorCode.API_USER_LOGIN_ERROR });
       });
       if (user) {
         this.config.setConfig("userInfo", {
@@ -19484,6 +20156,7 @@ var WebCall = (() => {
           fsPort: user.fsPort,
           iceInfo: user.iceInfo,
           iceGatheringTimeout: user.iceGatheringTimeout,
+          logGather: user.logGather,
           // encryptionType is in extra
           ...extra
         });
@@ -19499,12 +20172,7 @@ var WebCall = (() => {
       await this.user.setUserStatus(UserStatus.offline);
       if (this.config.isLogin()) {
         const { sessionId } = this.config.getConfig().userInfo;
-        this.unregister();
-        this.stop();
-        this.socket.gracefulClose();
-        this.api.loginOut({ sessionId }).catch((err) => {
-          this.logger.error(err, { errCode: ErrorCode.API_USER_LOGOUT_ERROR });
-        });
+        this.user.loginOut({ sessionId });
       }
       await this.hangup();
       this.socket.reset(false);
@@ -19547,14 +20215,12 @@ var WebCall = (() => {
         return;
       this.logger.debug("register");
       this.connect.register();
-      await this.user.setUserStatus(UserStatus.online);
     }
     async unregister() {
       if (!this.config.check())
         return;
       this.logger.debug("unregister");
       this.connect.unregister();
-      await this.user.setUserStatus(UserStatus.offline);
     }
     async stop() {
       await this.connect.stop();
@@ -19568,7 +20234,6 @@ var WebCall = (() => {
         return;
       }
       await this.callCenter.callEnd(true);
-      this.user.setUserStatus(UserStatus.catNap);
     }
     hold() {
       if (!this.config.check())
@@ -19609,12 +20274,6 @@ var WebCall = (() => {
         await this.user.setUserStatus(UserStatus.offline);
       }
     }
-    startRTTMonitoring() {
-      this.monitor.startRTTMonitoring();
-    }
-    stopRTTMonitoring() {
-      this.monitor.stopRTTMonitoring();
-    }
     on(event, callback) {
       this.logger.debug(`on ${event}`);
       this.listener.push({