@koi-design/callkit 2.0.4 → 2.0.5-beta.10

package/dist/index.global.js

@@ -3225,6 +3225,10 @@ var WebCall = (() => {
     isLoginOuting = false;
     async login(params) {
       if (this.isLogining) {
+        this.callKit.logger.info("login is already in progress cancel", {
+          caller: "Api.login",
+          content: { userName: params.userName, timestamp: params.timestamp }
+        });
         return;
       }
       this.isLogining = true;
@@ -3234,15 +3238,17 @@ var WebCall = (() => {
           method: "post",
           data: params
         });
-        this.isLogining = false;
         return res;
-      } catch (error) {
+      } finally {
         this.isLogining = false;
-        throw error;
       }
     }
     async loginOut(params) {
       if (this.isLoginOuting) {
+        this.callKit.logger.info("loginOut is already in progress cancel", {
+          caller: "Api.loginOut",
+          content: { sessionId: params.sessionId, timestamp: params.timestamp }
+        });
         return;
       }
       this.isLoginOuting = true;
@@ -3252,18 +3258,17 @@ var WebCall = (() => {
           method: "post",
           data: params
         });
-        this.isLoginOuting = false;
         return res;
-      } catch (error) {
+      } finally {
         this.isLoginOuting = false;
-        throw error;
       }
     }
     async trackLogs(log) {
       return this.post(
         { url: "/agent/user/sdkLog", method: "post", data: { content: [log] } },
         {
-          useFormData: true
+          useFormData: true,
+          skipLog: true
         }
       );
     }
@@ -3279,7 +3284,7 @@ var WebCall = (() => {
         data: params
       });
     }
-    async post(config, extra = {}) {
+    async post(config, extra = { skipLog: false }) {
       const { userInfo, host } = this.callKit.config.getConfig();
       const { sessionId } = userInfo;
       config.url = `${host}${config.url}`;
@@ -3302,11 +3307,37 @@ var WebCall = (() => {
       if (sessionId) {
         config.headers.sessionId = sessionId;
       }
+      const startTime = Date.now();
+      if (!extra.skipLog) {
+        this.callKit.logger.info("API Request Start", {
+          type: "API",
+          caller: "API.Request",
+          content: {
+            url: config.url,
+            headers: config.headers,
+            data: config.data,
+            extra,
+            startTime
+          }
+        });
+      }
       const res = await axios_default(config).catch(() => {
         this.callKit.config.reset();
       });
+      const endTime = Date.now();
+      if (!extra.skipLog) {
+        this.callKit.logger.info("API Request Finish", {
+          type: "API",
+          caller: "API.Request",
+          content: {
+            url: config.url,
+            duration: `${endTime - startTime}ms`,
+            response: res
+          }
+        });
+      }
       if (!res) {
-        this.callKit.config.reset();
+        this.callKit.reset();
         throw new Error("Network error");
       }
       const { code, data, message } = res;
@@ -3627,6 +3658,10 @@ var WebCall = (() => {
      * Agent no answer
      */
     AGENT_NO_ANSWER: "AGENT_NO_ANSWER",
+    /**
+     * Agent hang up
+     */
+    AGENT_HANG_UP: "AGENT_HANG_UP",
     /**
      * Call detail record push
      */
@@ -3668,6 +3703,18 @@ var WebCall = (() => {
     interval: 5e3,
     maxSize: 8192
   };
+  var SOCKET_RECONNECT_CONFIG = {
+    enabled: true,
+    maxAttempts: 3,
+    delay: 1e3,
+    pingInterval: 3e4,
+    pingTimeout: 5e3
+  };
+  var SIP_RECONNECT_CONFIG = {
+    enabled: true,
+    maxAttempts: 3,
+    delay: 1e3
+  };
 
   // core/call.ts
   var Call = class {
@@ -3681,14 +3728,14 @@ var WebCall = (() => {
       this.callKit.logger.info("callStart", {
         caller: "Call.callStart",
         content: {
-          startConfirm: this.callKit.socket.satrtConfirm
+          startConfirm: this.callKit.socket.startConfirm
         }
       });
-      if (!this.callKit.socket.satrtConfirm) {
+      if (!this.callKit.socket.startConfirm) {
         this.callKit.logger.warn("server not confirm start", {
           caller: "Call.callStart",
           content: {
-            startConfirm: this.callKit.socket.satrtConfirm
+            startConfirm: this.callKit.socket.startConfirm
           }
         });
         return;
@@ -3810,14 +3857,14 @@ var WebCall = (() => {
   // package.json
   var package_default = {
     name: "@koi-design/callkit",
-    version: "2.0.4",
+    version: "2.0.5-beta.10",
     description: "callkit",
     author: "koi",
     license: "ISC",
     scripts: {
       build: "tsup",
-      "build:watch": "tsup --watch",
-      dev: "vite",
+      start: "vite",
+      dev: "tsup --watch",
       lint: "eslint -c ../../.eslintrc.js --ext .jsx,.js,.tsx,.ts ./package --fix",
       release: "tsup && node scripts/pkg.js"
     },
@@ -3874,6 +3921,10 @@ var WebCall = (() => {
       audioRef: void 0,
       constrains: constrainsDefault,
       socket: "",
+      reconnect: {
+        sip: SIP_RECONNECT_CONFIG,
+        incall: SOCKET_RECONNECT_CONFIG
+      },
       userInfo: {
         wsUrl: "",
         logGather: false,
@@ -3958,7 +4009,16 @@ var WebCall = (() => {
       return true;
     }
     getTrackLogsConfig() {
-      return this.config?.trackLogs ?? trackLogsDefaultConfig;
+      return {
+        ...trackLogsDefaultConfig,
+        ...this.config?.trackLogs
+      };
+    }
+    getReconnectConfig(type) {
+      const config = this.config?.reconnect?.[type] ?? (type === "sip" ? SIP_RECONNECT_CONFIG : SOCKET_RECONNECT_CONFIG);
+      return {
+        ...config
+      };
     }
     enableTrackLogs(enabled) {
       this.config.trackLogs.enabled = enabled;
@@ -4084,16 +4144,22 @@ var WebCall = (() => {
     }
     catchLog(msg, extra, level) {
       const now = /* @__PURE__ */ new Date();
+      const { enabled } = this.callKit.config.getTrackLogsConfig();
+      const { userInfo } = this.callKit.config.getConfig();
+      const content = {
+        agentId: userInfo?.agentId,
+        sessionId: userInfo?.sessionId,
+        ...extra?.content ?? {}
+      };
       const log = {
         timestamp: now.toLocaleString().replace("T", " ").replace(".000Z", ""),
         level,
         message: msg,
         caller: extra?.caller,
         type: extra?.type,
-        content: extra?.content ?? {}
+        content
       };
       const logString = transformLog(log);
-      const { enabled } = this.callKit.config.getTrackLogsConfig();
       if (enabled) {
         this.pendingTrackLogs.push(logString);
       }
@@ -18519,10 +18585,6 @@ var WebCall = (() => {
   };
 
   // core/connect.ts
-  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, '"');
@@ -18554,10 +18616,6 @@ var WebCall = (() => {
   };
   var Connect = class {
     callKit;
-    /**
-     *@description  Reconnect config
-     */
-    reconnectConfig;
     /**
      *@description  Whether muted
      */
@@ -18597,14 +18655,26 @@ var WebCall = (() => {
     hasInvite = false;
     constructor(callKit) {
       this.callKit = callKit;
-      const { reconnect = {} } = this.callKit.config.getConfig();
-      this.reconnectConfig = {
-        ...DEFAULT_RECONNECT_CONFIG,
-        ...reconnect
-      };
+    }
+    get reconnectConfig() {
+      return this.callKit.config.getReconnectConfig("sip");
     }
     // current call id for invite data
     currentCallId = null;
+    getCurrentCallId() {
+      return this.currentCallId;
+    }
+    setOutgoing(outgoing) {
+      if (this.isOutgoing === outgoing)
+        return;
+      this.callKit.logger.info("setOutgoing", {
+        caller: "Connect.setOutgoing",
+        content: {
+          outgoing
+        }
+      });
+      this.isOutgoing = outgoing;
+    }
     setCallId(callId) {
       this.callKit.logger.info("setCallId", {
         caller: "Connect.setCallId",
@@ -18616,6 +18686,9 @@ var WebCall = (() => {
       this.callKit.trigger(KitEvent.KIT_CALL_ID_CHANGE, callId);
     }
     async reset() {
+      this.setOutgoing(false);
+      this.isUnprompted = false;
+      this.hasInvite = false;
       if (this.isHolding()) {
         await this.setHold(false);
       }
@@ -18635,9 +18708,6 @@ var WebCall = (() => {
       this.mediaStream = void 0;
       this.userAgent = void 0;
       this.registerer = void 0;
-      this.isOutgoing = false;
-      this.isUnprompted = false;
-      this.hasInvite = false;
       if (this.mediaStream) {
         try {
           closeStream(this.mediaStream);
@@ -18959,7 +19029,8 @@ var WebCall = (() => {
             caller: "Connect.register.onInvite",
             content: {
               invite,
-              isRegistered: this.isRegistered()
+              isRegistered: this.isRegistered(),
+              isOutgoing: this.isOutgoing
             }
           });
           this.currentSession = invite;
@@ -19096,9 +19167,7 @@ var WebCall = (() => {
               version: `${this.callKit.config.getConfig().version}`
             }
           });
-          await this.registerer.register().then(() => {
-            this.callKit.socket.send(SocketSendEvent.START);
-          }).catch(async (err) => {
+          await this.registerer.register().catch(async (err) => {
             this.callKit.reset();
             this.callKit.logger.error(err?.message, {
               caller: "Connect.register",
@@ -19110,9 +19179,8 @@ var WebCall = (() => {
           });
         },
         onDisconnect: (error) => {
-          console.log("onDisconnect", error);
           if (error) {
-            this.callKit.logger.info("SIP User Agent Disconnected with error", {
+            this.callKit.logger.warn("SIP User Agent Disconnected with error", {
               caller: "Connect.register",
               type: "SIP",
               content: {
@@ -19122,7 +19190,7 @@ var WebCall = (() => {
             });
             this.startReconnectTimer();
           } else {
-            this.callKit.logger.info("SIP User Agent Disconnected", {
+            this.callKit.logger.warn("SIP User Agent Disconnected", {
               caller: "Connect.register",
               type: "SIP",
               content: {}
@@ -19226,14 +19294,15 @@ var WebCall = (() => {
         return;
       }
       await this.registerer.unregister({ all: true }).catch((err) => {
-        this.callKit.reset();
-        this.callKit.logger.error(err, {
+        this.callKit.logger.warn(err, {
           caller: "Connect.unregister",
           type: "SIP",
           content: {
             errCode: ErrorCode.WEBRTC_CANCEL_REGISTER_ERROR
           }
         });
+      }).finally(() => {
+        this.setRegister(false);
       });
       await this.userAgent?.stop().catch((err) => {
         this.callKit.logger.warn(err, {
@@ -19253,7 +19322,7 @@ var WebCall = (() => {
           callback
         }
       });
-      this.isOutgoing = true;
+      this.setOutgoing(true);
       if (!this.isRegistered()) {
         await this.register();
       }
@@ -19267,6 +19336,8 @@ var WebCall = (() => {
      * @param register
      */
     setRegister(register) {
+      if (this.isRegister === register)
+        return;
       this.callKit.logger.info("connect setRegister", {
         caller: "Connect.setRegister",
         type: "SIP",
@@ -19308,7 +19379,7 @@ var WebCall = (() => {
           connectStatus: this.connectStatus
         }
       });
-      this.isOutgoing = false;
+      this.setOutgoing(false);
       this.isUnprompted = isUnprompted;
       this.setHold(false);
       this.setMute(false);
@@ -19336,6 +19407,7 @@ var WebCall = (() => {
         }
         this.setConnectStatus(CallStatus.init);
         this.callKit.trigger(KitEvent.CALL_END, /* @__PURE__ */ new Date());
+        this.setCallId(null);
       } catch (err) {
         this.callKit.trigger(KitEvent.CALL_END, /* @__PURE__ */ new Date());
         this.callKit.reset();
@@ -19479,33 +19551,46 @@ var WebCall = (() => {
   };
 
   // core/socket.ts
-  var RECONNECT_CONFIG = {
-    enabled: true,
-    maxAttempts: 3,
-    delay: 1e3,
-    pingInterval: 3e4,
-    pingTimeout: 5e3
-  };
   var Socket = class {
     callKit;
     ws;
-    socketConfig;
     lastPingTime = void 0;
-    isConnected = false;
     pingTimer;
-    // Whether received start confirmation
-    satrtConfirm = false;
+    /**
+     * @description reconnect timer
+     */
     reconnectTimer;
-    isReconnecting = false;
+    /**
+     * @description reconnect attempts
+     */
     reconnectAttempts = 0;
-    socketError = false;
+    /**
+     * @description connect auth state
+     * @default {
+     *   startConfirm: false,
+     *   isConnected: false,
+     *   isReconnecting: false,
+     *   isAuthenticated: false,
+     *   isError: false
+     * }
+     */
+    connectAuthState = {
+      startConfirm: false,
+      isConnected: false,
+      isReconnecting: false,
+      isError: false
+    };
+    get startConfirm() {
+      return this.connectAuthState.startConfirm;
+    }
+    get isError() {
+      return this.connectAuthState.isError;
+    }
     constructor(callKit) {
       this.callKit = callKit;
-      const { reconnect } = this.callKit.config.getConfig();
-      this.socketConfig = {
-        ...RECONNECT_CONFIG,
-        ...reconnect
-      };
+    }
+    get reconnectConfig() {
+      return this.callKit.config.getReconnectConfig("incall");
     }
     init() {
       const { socket } = this.callKit.config.getConfig();
@@ -19518,19 +19603,25 @@ var WebCall = (() => {
       });
       this.connect(socket);
     }
+    setConnectAuthState(key, value) {
+      if (this.connectAuthState[key] === value)
+        return;
+      this.connectAuthState[key] = value;
+    }
     handleDisconnect() {
-      this.isConnected = false;
-      if (!this.callKit.config.isLogin() || !this.socketConfig.enabled) {
-        this.reset();
+      this.setConnectAuthState("isConnected", false);
+      const { enabled } = this.reconnectConfig;
+      if (!this.callKit.config.isLogin() || !enabled) {
+        this.callKit.reset();
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_NOT_CONNECTED"
         });
         return;
       }
-      if (this.socketError) {
+      if (this.connectAuthState.isReconnecting) {
         return;
       }
-      if (this.isReconnecting) {
+      if (this.connectAuthState.isError) {
         return;
       }
       this.attemptReconnect();
@@ -19551,7 +19642,7 @@ var WebCall = (() => {
         });
       }
       this.ws = void 0;
-      this.isConnected = false;
+      this.setConnectAuthState("isConnected", false);
     }
     connect(socketUrl) {
       if (this.ws) {
@@ -19569,11 +19660,12 @@ var WebCall = (() => {
         type: "INCALL",
         content: { ev }
       });
-      this.socketError = false;
-      this.isConnected = true;
+      this.setConnectAuthState("isConnected", true);
       this.lastPingTime = Date.now();
       this.checkPing();
-      if (this.isReconnecting) {
+      this.send(SocketSendEvent.START);
+      if (this.connectAuthState.isReconnecting) {
+        this.setConnectAuthState("isReconnecting", false);
         this.callKit.logger.info("reconnect success", {
           caller: "Socket.onOpen",
           type: "INCALL",
@@ -19586,15 +19678,32 @@ var WebCall = (() => {
           event: "INCALL_RECONNECT_SUCCESS"
         });
       }
-      this.resetReconnectState();
     }
-    resetReconnectState() {
-      this.isReconnecting = false;
+    cleanReconnectState() {
       this.reconnectAttempts = 0;
       if (this.reconnectTimer) {
         clearTimeout(this.reconnectTimer);
         this.reconnectTimer = void 0;
       }
+      this.setConnectAuthState("isReconnecting", false);
+      this.setConnectAuthState("isError", false);
+    }
+    resetConnectState() {
+      this.connectAuthState = {
+        startConfirm: false,
+        isConnected: false,
+        isReconnecting: false,
+        isError: false
+      };
+      this.cleanReconnectState();
+      this.callKit.logger.info("reset connect state", {
+        caller: "Socket.resetConnectState",
+        type: "INCALL",
+        content: {
+          reconnectAttempts: this.reconnectAttempts,
+          connectAuthState: this.connectAuthState
+        }
+      });
     }
     onClose(ev) {
       this.callKit.logger.info("socket onClose", {
@@ -19605,7 +19714,6 @@ var WebCall = (() => {
       this.handleDisconnect();
     }
     onError(ev) {
-      this.socketError = true;
       this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
         event: "INCALL_CONNECT_ERROR",
         err: ev
@@ -19644,7 +19752,7 @@ var WebCall = (() => {
         });
         content = data.data;
       }
-      this.callKit.logger.info("socket onMessage", {
+      this.callKit.logger.info(`socket onMessage: ${data.event}`, {
         caller: "Socket.onMessage",
         type: "INCALL",
         content: {
@@ -19653,178 +19761,105 @@ var WebCall = (() => {
         }
       });
       this.confirmAck(data);
+      const callUuid = content?.callUuid || "";
       if (data.event === SocketReceiveEvent.PONG) {
         this.lastPingTime = Date.now();
         return;
       }
       if (data.event === SocketReceiveEvent.START_CONFIRM) {
-        this.callKit.logger.info("start confirm success", {
-          caller: "Socket.onMessage",
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.START_CONFIRM
-          }
-        });
-        this.satrtConfirm = true;
-      }
-      if (data.event === SocketReceiveEvent.CALL_SUCCESS) {
-        this.callKit.logger.info("call success", {
-          caller: "Socket.onMessage",
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.CALL_SUCCESS
-          }
-        });
-      }
-      if (data.event === SocketReceiveEvent.CALL_FAILED) {
-        this.callKit.logger.info(data.msg, {
-          caller: "Socket.onMessage",
-          type: "INCALL",
-          content: {
-            data: content,
-            errCode: ErrorCode.SOCKET_CALL_ERROR
-          }
-        });
+        this.setConnectAuthState("startConfirm", true);
+        this.cleanReconnectState();
       }
       if (data.event === SocketReceiveEvent.CUSTOMER_RINGING) {
-        this.callKit.trigger(KitEvent.CALL_RINGING, /* @__PURE__ */ new Date());
-        this.callKit.logger.info(data.msg, {
-          caller: `Socket.onMessage:${data.event}`,
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.CUSTOMER_RINGING
-          }
+        this.callKit.trigger(KitEvent.CALL_RINGING, {
+          time: /* @__PURE__ */ new Date(),
+          callUuid
         });
       }
       if (data.event === SocketReceiveEvent.CUSTOMER_PICK_UP) {
-        this.callKit.logger.info(data.msg, {
-          caller: "Socket.onMessage",
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.CUSTOMER_PICK_UP
-          }
+        this.callKit.trigger(KitEvent.CALL_PICK_UP, {
+          time: /* @__PURE__ */ new Date(),
+          callUuid
         });
-        this.callKit.trigger(KitEvent.CALL_PICK_UP, /* @__PURE__ */ new Date());
       }
       if (data.event === SocketReceiveEvent.AGENT_PICK_UP) {
-        this.callKit.logger.info(data.msg, {
-          caller: "Socket.onMessage",
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.AGENT_PICK_UP
-          }
+        this.callKit.trigger(KitEvent.AGENT_PICK_UP, {
+          time: /* @__PURE__ */ new Date(),
+          callUuid
         });
-        this.callKit.trigger(KitEvent.AGENT_PICK_UP, /* @__PURE__ */ new Date());
       }
       if (data.event === SocketReceiveEvent.CUSTOMER_HANG_UP) {
-        this.callKit.logger.info(data.msg, {
-          caller: `Socket.onMessage:${data.event}`,
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.CUSTOMER_HANG_UP
-          }
+        this.callKit.trigger(KitEvent.CALL_HANG_UP, {
+          time: /* @__PURE__ */ new Date(),
+          callUuid
         });
-        this.callKit.trigger(KitEvent.CALL_HANG_UP, /* @__PURE__ */ new Date());
-        if (content?.callUuid) {
-          this.callKit.connect.socketTriggerHangup(content.callUuid);
+        if (callUuid) {
+          this.callKit.connect.socketTriggerHangup(callUuid);
         }
       }
       if (data.event === SocketReceiveEvent.CUSTOMER_NO_ANSWER) {
-        this.callKit.logger.info(data.msg, {
-          caller: "Socket.onMessage",
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.CUSTOMER_NO_ANSWER
-          }
+        this.callKit.trigger(KitEvent.CALL_NO_ANSWER, {
+          time: /* @__PURE__ */ new Date(),
+          callUuid
         });
-        this.callKit.trigger(KitEvent.CALL_NO_ANSWER);
-        if (content?.callUuid) {
-          this.callKit.connect.socketTriggerHangup(content.callUuid);
+        if (callUuid) {
+          this.callKit.connect.socketTriggerHangup(callUuid);
         }
       }
       if (data.event === SocketReceiveEvent.CALL_CDR) {
-        this.callKit.logger.info(data.msg, {
-          caller: `Socket.onMessage:${data.event}`,
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.CALL_CDR
-          }
-        });
-        this.callKit.trigger(KitEvent.CALL_CDR, content);
-      }
-      if (data.event === SocketReceiveEvent.STOP_CONFIRM) {
-        this.callKit.logger.info(data.msg, {
-          caller: `Socket.onMessage:${data.event}`,
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.STOP_CONFIRM
-          }
+        this.callKit.trigger(KitEvent.CALL_CDR, {
+          time: /* @__PURE__ */ new Date(),
+          callUuid,
+          ...content
         });
       }
       if (data.event === SocketReceiveEvent.CLOSE) {
         const { userInfo } = this.callKit.config.getConfig();
-        this.callKit.logger.info(data.msg, {
-          caller: `Socket.onMessage:${data.event}`,
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.CLOSE
-          }
-        });
-        this.send(SocketSendEvent.END, {
-          agentId: userInfo.agentId
-        });
+        this.send(SocketSendEvent.END, { agentId: userInfo.agentId, callUuid });
       }
       if (data.event === SocketReceiveEvent.ERROR) {
-        this.socketError = true;
+        this.setConnectAuthState("isError", true);
         this.callKit.reset();
         this.callKit.logger.error(data.msg, {
           caller: `Socket.onMessage:${data.event}`,
           type: "INCALL",
           content: {
             errCode: ErrorCode.SOKET_SERVER_ERROR,
-            data: content
+            data: content,
+            callUuid
           }
         });
       }
       if (data.event === SocketReceiveEvent.SESSION_ERROR) {
-        this.socketError = true;
+        this.setConnectAuthState("isError", true);
         this.callKit.reset();
         this.callKit.logger.error(data.msg, {
           caller: `Socket.onMessage:${data.event}`,
           type: "INCALL",
           content: {
             data: content,
-            event: SocketReceiveEvent.SESSION_ERROR
+            event: SocketReceiveEvent.SESSION_ERROR,
+            callUuid
           }
         });
       }
       if (data.event === SocketReceiveEvent.AGENT_NO_ANSWER) {
-        this.callKit.logger.info(data.msg, {
-          caller: `Socket.onMessage:${data.event}`,
-          type: "INCALL",
-          content: {
-            data: content,
-            event: SocketReceiveEvent.AGENT_NO_ANSWER
-          }
-        });
-        if (content?.callUuid) {
-          this.callKit.connect.socketTriggerHangup(content.callUuid);
+        if (callUuid) {
+          this.callKit.connect.socketTriggerHangup(callUuid);
         }
       }
-      this.callKit.trigger(KitEvent.SERVER_SOCKET_EVENT, data);
+      if (data.event === SocketReceiveEvent.AGENT_HANG_UP) {
+        if (callUuid) {
+          this.callKit.connect.socketTriggerHangup(callUuid);
+        }
+      }
+      this.callKit.trigger(KitEvent.SERVER_SOCKET_EVENT, {
+        ...data,
+        callUuid
+      });
     }
     send(event, message) {
-      if (!this.isConnected) {
+      if (!this.connectAuthState.isConnected) {
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_NOT_CONNECTED"
         });
@@ -19883,23 +19918,16 @@ var WebCall = (() => {
       }
     }
     ping() {
-      if (!this.isConnected)
+      if (!this.connectAuthState.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();
-      const { pingInterval, pingTimeout } = this.socketConfig;
+      const { pingInterval, pingTimeout } = this.reconnectConfig;
       if (now - this.lastPingTime > pingInterval + pingTimeout) {
-        if (this.ws && this.isConnected) {
+        if (this.ws && this.connectAuthState.isConnected) {
           this.ws.close(4001, "ping timeout");
         } else {
-          this.reset();
+          this.callKit.reset();
         }
         this.callKit.logger.error("socket ping timeout", {
           caller: "Socket.ping",
@@ -19915,21 +19943,28 @@ var WebCall = (() => {
         clearInterval(this.pingTimer);
       }
       this.ping();
+      const { pingInterval } = this.reconnectConfig;
       this.pingTimer = setInterval(() => {
         this.ping();
-      }, this.socketConfig.pingInterval);
+      }, pingInterval);
     }
     /**
      * reset socket connection and all states
      */
-    async reset() {
+    async reset(config) {
+      const { force = false } = config || {};
       if (this.pingTimer) {
         clearInterval(this.pingTimer);
         this.pingTimer = void 0;
       }
-      this.resetReconnectState();
+      if (force) {
+        this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
+          event: "INCALL_RESET"
+        });
+        this.resetConnectState();
+      }
       this.lastPingTime = void 0;
-      this.satrtConfirm = false;
+      this.setConnectAuthState("startConfirm", false);
       this.clearWebSocket();
     }
     attemptReconnect() {
@@ -19937,11 +19972,12 @@ var WebCall = (() => {
         clearTimeout(this.reconnectTimer);
         this.reconnectTimer = void 0;
       }
-      if (this.reconnectAttempts >= this.socketConfig.maxAttempts) {
+      const { maxAttempts } = this.reconnectConfig;
+      if (this.reconnectAttempts >= maxAttempts) {
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_RECONNECT_ERROR"
         });
-        this.reset();
+        this.callKit.reset();
         this.callKit.logger.error("Maximum reconnection attempts reached", {
           caller: "Socket.attemptReconnect",
           type: "INCALL",
@@ -19957,17 +19993,17 @@ var WebCall = (() => {
           event: "INCALL_RECONNECT_START"
         });
       }
-      this.isReconnecting = true;
+      this.setConnectAuthState("isReconnecting", true);
       this.reconnectAttempts += 1;
-      const { delay } = this.socketConfig;
+      const { delay } = this.reconnectConfig;
       this.callKit.logger.info(
-        `Preparing reconnection attempt ${this.reconnectAttempts}/${this.socketConfig.maxAttempts}, delay: ${delay}ms`,
+        `Preparing reconnection attempt ${this.reconnectAttempts}/${maxAttempts}, delay: ${delay}ms`,
         {
           caller: "Socket.attemptReconnect",
           type: "INCALL",
           content: {
             reconnectAttempts: this.reconnectAttempts,
-            maxAttempts: this.socketConfig.maxAttempts,
+            maxAttempts,
             delay
           }
         }
@@ -19994,17 +20030,34 @@ var WebCall = (() => {
       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.logger = new Logger(this, options.log);
+      if (options.log) {
+        this.config.setConfig("log", options.log);
+      }
+      if (options.trackLogs) {
+        this.config.setConfig("trackLogs", {
+          ...trackLogsDefaultConfig,
+          ...options.trackLogs
+        });
+      }
+      if (options.audioRef) {
+        this.config.setConfig("audioRef", options.audioRef);
+      }
+      if (options.host) {
+        this.config.setConfig("host", options.host);
+      }
       this.config.setConfig(
         "constrains",
         options.constrains || constrainsDefault
       );
       this.config.setConfig("socket", options.socket);
-      this.config.setConfig("reconnect", options.reconnect);
-      this.logger = new Logger(this, options.log);
+      this.config.setConfig("reconnect", {
+        sip: { ...SIP_RECONNECT_CONFIG, ...options.reconnect?.sip || {} },
+        incall: {
+          ...SOCKET_RECONNECT_CONFIG,
+          ...options.reconnect?.incall || {}
+        }
+      });
       this.logger.info("callKit init", {
         caller: "CallKit.init",
         content: options
@@ -20042,10 +20095,18 @@ var WebCall = (() => {
           encryptionPassword
         }
       });
+      if (this.socket.isError) {
+        this.logger.warn("socket is error", {
+          caller: "CallKit.login",
+          content: { username, password, extra, socketError: this.socket.isError }
+        });
+        return;
+      }
       try {
         const user = await this.api.login({
           userName: username,
-          password: encryptionPassword
+          password: encryptionPassword,
+          timestamp: Date.now()
         });
         if (user) {
           this.config.setConfig("userInfo", {
@@ -20091,9 +20152,9 @@ var WebCall = (() => {
       if (this.config.isLogin()) {
         const { sessionId } = userInfo;
         try {
-          await this.api.loginOut({ sessionId });
+          await this.api.loginOut({ sessionId, timestamp: Date.now() });
         } catch (error) {
-          this.logger.error(error, {
+          this.logger.warn(error, {
             caller: "CallKit.logout",
             content: {
               errCode: ErrorCode.API_USER_LOGOUT_ERROR
@@ -20103,8 +20164,9 @@ var WebCall = (() => {
       }
       if (isReset) {
         await this.reset();
+      } else {
+        this.config.reset();
       }
-      this.trigger(KitEvent.KIT_LOGIN_CHANGE, false);
     }
     async call(extno = "", options = {
       sourceType: CallSourceType.phoneNum,
@@ -20169,9 +20231,6 @@ var WebCall = (() => {
       });
       this.connect.unregister();
     }
-    async stop() {
-      await this.connect.stop();
-    }
     async hangup() {
       if (!this.config.check())
         return;
@@ -20240,7 +20299,7 @@ var WebCall = (() => {
      * set userstatus
      * @param status
      */
-    async setUserStatus(status) {
+    async setUserStatus(status, extra = {}) {
       const { agentId } = this.config.getConfig().userInfo;
       this.logger.info("setUserStatus", {
         caller: "CallKit.setUserStatus",
@@ -20251,14 +20310,24 @@ var WebCall = (() => {
       });
       await this.api.updateUserStatus({
         agentId,
-        userStatus: status
+        userStatus: status,
+        timestamp: Date.now(),
+        ...extra
       });
     }
-    async reset() {
+    /**
+     * reset callkit
+     * @description recover the callkit to the initial state
+     * @default force is false
+     * @param config.force is true, the callkit reset socket connection and all states
+     */
+    async reset(config) {
+      const { force = false } = config || {};
       this.logger.info("reset", {
         caller: "CallKit.reset",
         content: {
-          connectStatus: this.connect.connectStatus
+          connectStatus: this.connect.connectStatus,
+          force
         }
       });
       if (this.connect.isCalling()) {
@@ -20267,9 +20336,10 @@ var WebCall = (() => {
       await this.connect.reset();
       if (this.config.isLogin()) {
         await this.logout({ isReset: false });
+      } else {
+        await this.config.reset();
       }
-      await this.config.reset();
-      await this.socket.reset();
+      await this.socket.reset({ force });
     }
     on(event, callback) {
       this.listener.push({