@koi-design/callkit 2.0.5 → 2.1.0-beta.1

package/dist/index.global.js

@@ -3225,6 +3225,11 @@ var WebCall = (() => {
     isLoginOuting = false;
     async login(params) {
       if (this.isLogining) {
+        this.callKit.logger.info("login is already in progress cancel", {
+          caller: "Api.login",
+          type: "API",
+          content: { userName: params.userName, timestamp: params.timestamp }
+        });
         return;
       }
       this.isLogining = true;
@@ -3234,15 +3239,18 @@ 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", {
+          type: "API",
+          caller: "Api.loginOut",
+          content: { sessionId: params.sessionId, timestamp: params.timestamp }
+        });
         return;
       }
       this.isLoginOuting = true;
@@ -3252,20 +3260,29 @@ 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
-        }
-      );
+      try {
+        const { userInfo, host } = this.callKit.config.getConfig();
+        const { sessionId } = userInfo;
+        const formData = new FormData();
+        formData.append("content", JSON.stringify([log]));
+        const config = {
+          url: `${host}/agent/user/sdkLog`,
+          method: "post",
+          data: formData,
+          headers: {
+            ...sessionId ? { sessionId } : {}
+          }
+        };
+        await axios_default(config).catch(() => {
+        });
+      } catch (error) {
+      }
     }
     /**
      *
@@ -3279,7 +3296,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 +3319,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();
+        this.callKit.config.reset("api request error");
       });
+      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;
@@ -3314,7 +3357,7 @@ var WebCall = (() => {
         return data;
       }
       if (code === "100013") {
-        this.callKit.config.reset();
+        this.callKit.config.reset("api request error");
       }
       throw new Error(message ?? "Request failed");
     }
@@ -3627,6 +3670,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
      */
@@ -3643,7 +3690,8 @@ var WebCall = (() => {
      * Error
      */
     ERROR: "ERROR",
-    SESSION_ERROR: "SESSION_ERROR"
+    SESSION_ERROR: "SESSION_ERROR",
+    WAITING_QUEUE: "WAITING_QUEUE"
   };
   var EncryptionMethod = {
     NONE: "NONE",
@@ -3666,7 +3714,19 @@ var WebCall = (() => {
   var trackLogsDefaultConfig = {
     enabled: false,
     interval: 5e3,
-    maxSize: 8192
+    maxSize: 4096
+  };
+  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
@@ -3681,14 +3741,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 +3870,14 @@ var WebCall = (() => {
   // package.json
   var package_default = {
     name: "@koi-design/callkit",
-    version: "2.0.5",
+    version: "2.1.0-beta.1",
     description: "callkit",
     author: "koi",
     license: "ISC",
     scripts: {
       build: "tsup",
-      "build:w": "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 +3934,10 @@ var WebCall = (() => {
       audioRef: void 0,
       constrains: constrainsDefault,
       socket: "",
+      reconnect: {
+        sip: SIP_RECONNECT_CONFIG,
+        incall: SOCKET_RECONNECT_CONFIG
+      },
       userInfo: {
         wsUrl: "",
         logGather: false,
@@ -3912,7 +3976,12 @@ var WebCall = (() => {
         }
       });
     };
-    reset = async () => {
+    reset = async (form) => {
+      this.callKit.logger.info(`Reset User Info ${form}`, {
+        caller: "Config.reset",
+        type: "OTHER",
+        content: {}
+      });
       if (this.isLogin()) {
         this.config.userInfo = {
           wsUrl: "",
@@ -3958,7 +4027,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;
@@ -3998,7 +4076,7 @@ var WebCall = (() => {
         this.flushTrackLogs();
       }, interval);
     }
-    flushTrackLogs() {
+    async flushTrackLogs() {
       if (this.pendingTrackLogs.length === 0) {
         return;
       }
@@ -4007,26 +4085,29 @@ var WebCall = (() => {
         try {
           const chunks = [];
           let currentChunk = [];
-          let currentSize = 0;
           for (const log of this.pendingTrackLogs) {
-            const logSize = getByteSize(log);
-            const separator = currentChunk.length > 0 ? "\n" : "";
-            const separatorSize = getByteSize(separator);
-            if (currentSize + logSize + separatorSize > maxSize && currentChunk.length > 0) {
+            const testChunk = currentChunk.length > 0 ? `${currentChunk.join("\n")}
+${log}` : log;
+            const actualSize = getByteSize(JSON.stringify([testChunk]));
+            if (actualSize > maxSize && currentChunk.length > 0) {
               chunks.push(currentChunk.join("\n"));
               currentChunk = [log];
-              currentSize = logSize;
             } else {
               currentChunk.push(log);
-              currentSize += logSize + separatorSize;
             }
           }
           if (currentChunk.length > 0) {
             chunks.push(currentChunk.join("\n"));
           }
-          for (const chunk of chunks) {
-            this.callKit.api.trackLogs(chunk);
-          }
+          await chunks.reduce(async (previousPromise, chunk, index) => {
+            await previousPromise;
+            if (index > 0) {
+              await new Promise((resolve) => {
+                setTimeout(resolve, 1e3);
+              });
+            }
+            await this.callKit.api.trackLogs(chunk);
+          }, Promise.resolve());
           this.pendingTrackLogs = [];
         } catch (error) {
           console.error(error);
@@ -4084,16 +4165,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 = {
+        ...extra?.content ?? {},
+        agentId: userInfo?.agentId,
+        sessionId: userInfo?.sessionId
+      };
       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,11 +18606,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, '"');
     return corrected;
@@ -18554,10 +18636,6 @@ var WebCall = (() => {
   };
   var Connect = class {
     callKit;
-    /**
-     *@description  Reconnect config
-     */
-    reconnectConfig;
     /**
      *@description  Whether muted
      */
@@ -18582,6 +18660,10 @@ var WebCall = (() => {
      *@description  Whether it's a re-connected
      */
     isReConnected = false;
+    /**
+     *@description  Whether it's a referring
+     */
+    isRefering = false;
     // sipConnected = false;
     /**
      *@description  Whether it's an outgoing call
@@ -18597,14 +18679,48 @@ 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;
+    }
+    setRefering(refering) {
+      if (this.isRefering === refering)
+        return;
+      this.callKit.logger.info("setRefering", {
+        caller: "Connect.setRefering",
+        content: {
+          refering
+        }
+      });
+      this.isRefering = refering;
+    }
+    setIsReConnected(isReConnected) {
+      if (this.isReConnected === isReConnected)
+        return;
+      this.callKit.logger.info("setIsReConnected", {
+        caller: "Connect.setIsReConnected",
+        content: {
+          isReConnected
+        }
+      });
+      this.isReConnected = isReConnected;
+    }
+    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 +18732,15 @@ var WebCall = (() => {
       this.callKit.trigger(KitEvent.KIT_CALL_ID_CHANGE, callId);
     }
     async reset() {
+      this.setOutgoing(false);
+      this.isUnprompted = false;
+      this.hasInvite = false;
+      if (this.isRefering) {
+        this.setRefering(false);
+      }
+      if (this.isReConnected) {
+        this.setIsReConnected(false);
+      }
       if (this.isHolding()) {
         await this.setHold(false);
       }
@@ -18635,9 +18760,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);
@@ -18654,7 +18776,6 @@ var WebCall = (() => {
         }
       }
       this.setConnectStatus(CallStatus.init);
-      this.clearHeartbeat();
     }
     getAduioReference() {
       const { audioRef } = this.callKit.config.getConfig();
@@ -18719,28 +18840,6 @@ var WebCall = (() => {
     isInit() {
       return this.connectStatus === CallStatus.init;
     }
-    heartbeatInterval;
-    heartbeatFlag = MAX_HEARTBEAT_COUNT;
-    clearHeartbeat() {
-      if (this.heartbeatInterval) {
-        clearInterval(this.heartbeatInterval);
-        this.heartbeatInterval = null;
-      }
-      this.heartbeatFlag = MAX_HEARTBEAT_COUNT;
-    }
-    startHeartbeat() {
-      this.heartbeatFlag = MAX_HEARTBEAT_COUNT;
-      this.clearHeartbeat();
-      this.heartbeatInterval = setInterval(() => {
-        this.heartbeatFlag -= 1;
-        if (this.heartbeatFlag <= 0) {
-          this.heartbeatFlag = MAX_HEARTBEAT_COUNT;
-          this.callKit.trigger(KitEvent.SIP_CONNECT_EVENT, {
-            event: "OPTIONS_HEARTBEAT_EXPIRED"
-          });
-        }
-      }, 1e3);
-    }
     socketTriggerHangup(callId) {
       if (!this.isCalling() || callId !== this.currentCallId)
         return;
@@ -18753,6 +18852,136 @@ var WebCall = (() => {
       });
       this.callKit.hangup();
     }
+    /**
+     * Setup registerer and bind stateChange listener
+     * @private
+     */
+    setupRegisterer() {
+      if (!this.userAgent) {
+        this.callKit.logger.warn("userAgent is not initialized", {
+          caller: "Connect.setupRegisterer",
+          content: {
+            errCode: ErrorCode.WEBRTC_USER_AGENT_ERROR
+          }
+        });
+        return;
+      }
+      const { userInfo } = this.callKit.config.getConfig();
+      const { userPart, fsIp, fsPort } = userInfo;
+      const registererOptions = {};
+      this.registerer = new Registerer(this.userAgent, registererOptions);
+      this.registerer.stateChange.addListener((state) => {
+        switch (state) {
+          case RegistererState.Initial:
+            this.callKit.logger.info("registerer stateChange Initial", {
+              caller: "Connect.setupRegisterer.registererStateChange",
+              type: "SIP",
+              content: {
+                registererState: state,
+                isRegistered: this.isRegistered()
+              }
+            });
+            this.setRegister(false);
+            this.setConnectStatus(CallStatus.init);
+            this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
+              registererState: state,
+              isRegistered: this.isRegistered()
+            });
+            break;
+          case RegistererState.Registered:
+            this.callKit.logger.info("registerer stateChange Registered", {
+              caller: "Connect.setupRegisterer.registererStateChange",
+              type: "SIP",
+              content: {
+                registererState: state,
+                isRegistered: this.isRegistered()
+              }
+            });
+            this.setRegister(true);
+            if (this.isReConnected) {
+              if (this.currentSession && (this.currentSession.state === SessionState2.Established || this.currentSession.state === SessionState2.Establishing) && this.isCalling()) {
+                const selfUri = `sip:manualCallAgent${userPart}@${fsIp}:${fsPort}`;
+                this.callKit.logger.info(
+                  "Reconnected, referring active session to self",
+                  {
+                    caller: "Connect.setupRegisterer.registererStateChange",
+                    type: "SIP",
+                    content: {
+                      selfUri,
+                      sessionState: this.currentSession.state,
+                      connectStatus: this.connectStatus
+                    }
+                  }
+                );
+                this.refer(selfUri).catch((err) => {
+                  this.callKit.logger.error(err, {
+                    caller: "Connect.setupRegisterer.registererStateChange",
+                    type: "SIP",
+                    content: {
+                      errCode: ErrorCode.WEBRTC_CALL_INVITE_ERROR,
+                      selfUri
+                    }
+                  });
+                });
+              } else {
+                this.callKit.logger.warn(
+                  "Reconnected but no active session to refer",
+                  {
+                    caller: "Connect.setupRegisterer.registererStateChange",
+                    type: "SIP",
+                    content: {
+                      hasCurrentSession: !!this.currentSession,
+                      sessionState: this.currentSession?.state,
+                      connectStatus: this.connectStatus,
+                      isCalling: this.isCalling()
+                    }
+                  }
+                );
+              }
+              this.setIsReConnected(false);
+            }
+            this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
+              registererState: state,
+              isRegistered: this.isRegistered()
+            });
+            break;
+          case RegistererState.Terminated:
+            this.callKit.logger.info("registerer stateChange Terminated", {
+              caller: "Connect.setupRegisterer.registererStateChange",
+              type: "SIP",
+              content: {
+                registererState: state,
+                isRegistered: this.isRegistered()
+              }
+            });
+            this.setRegister(false);
+            this.setConnectStatus(CallStatus.init);
+            this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
+              registererState: state,
+              isRegistered: this.isRegistered()
+            });
+            break;
+          case RegistererState.Unregistered:
+            this.callKit.logger.info("registerer stateChange Unregistered", {
+              caller: "Connect.setupRegisterer.registererStateChange",
+              type: "SIP",
+              content: {
+                isRegistered: this.isRegistered(),
+                registererState: state
+              }
+            });
+            this.setRegister(false);
+            this.setConnectStatus(CallStatus.init);
+            this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
+              registererState: state,
+              isRegistered: this.isRegistered()
+            });
+            break;
+          default:
+            break;
+        }
+      });
+    }
     async register() {
       if (this.connectStatus !== CallStatus.init) {
         if (this.isRegistered()) {
@@ -18854,9 +19083,6 @@ var WebCall = (() => {
         const core = userAgent.userAgentCore;
         const originalReceiveIncomingRequestFromTransport = core.receiveIncomingRequestFromTransport.bind(core);
         core.receiveIncomingRequestFromTransport = (request2) => {
-          if (request2.method === "OPTIONS") {
-            that.startHeartbeat();
-          }
           that.callKit.logger.info(`SIP Receive: ${request2?.method}`, {
             caller: "Connect.register.observeSocketStatus.receiveRequest",
             type: "SIP",
@@ -18866,6 +19092,20 @@ var WebCall = (() => {
           });
           return originalReceiveIncomingRequestFromTransport(request2);
         };
+        const originalReceiveIncomingResponseFromTransport = core.receiveIncomingResponseFromTransport.bind(core);
+        core.receiveIncomingResponseFromTransport = (response) => {
+          that.callKit.logger.info(
+            `SIP Receive Response: ${response?.statusCode} ${response?.reasonPhrase}`,
+            {
+              caller: "Connect.register.observeSocketStatus.receiveResponse",
+              type: "SIP",
+              content: {
+                response
+              }
+            }
+          );
+          return originalReceiveIncomingResponseFromTransport(response);
+        };
         const { transport } = userAgent;
         if (transport) {
           const originalSend = transport.send.bind(transport);
@@ -18881,77 +19121,7 @@ var WebCall = (() => {
           };
         }
       };
-      const registererOptions = {};
-      this.registerer = new Registerer(this.userAgent, registererOptions);
-      this.registerer.stateChange.addListener((state) => {
-        switch (state) {
-          case RegistererState.Initial:
-            this.callKit.logger.info("registerer stateChange Initial", {
-              caller: "Connect.register.registererStateChange",
-              type: "SIP",
-              content: {
-                registererState: state,
-                isRegistered: this.isRegistered()
-              }
-            });
-            this.setRegister(false);
-            this.setConnectStatus(CallStatus.init);
-            this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
-              registererState: state,
-              isRegistered: this.isRegistered()
-            });
-            break;
-          case RegistererState.Registered:
-            this.callKit.logger.info("registerer stateChange Registered", {
-              caller: "Connect.register.registererStateChange",
-              type: "SIP",
-              content: {
-                registererState: state,
-                isRegistered: this.isRegistered()
-              }
-            });
-            this.setRegister(true);
-            this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
-              registererState: state,
-              isRegistered: this.isRegistered()
-            });
-            break;
-          case RegistererState.Terminated:
-            this.callKit.logger.info("registerer stateChange Terminated", {
-              caller: "Connect.register.registererStateChange",
-              type: "SIP",
-              content: {
-                registererState: state,
-                isRegistered: this.isRegistered()
-              }
-            });
-            this.setRegister(false);
-            this.setConnectStatus(CallStatus.init);
-            this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
-              registererState: state,
-              isRegistered: this.isRegistered()
-            });
-            break;
-          case RegistererState.Unregistered:
-            this.callKit.logger.info("registerer stateChange Unregistered", {
-              caller: "Connect.register.registererStateChange",
-              type: "SIP",
-              content: {
-                isRegistered: this.isRegistered(),
-                registererState: state
-              }
-            });
-            this.setRegister(false);
-            this.setConnectStatus(CallStatus.init);
-            this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
-              registererState: state,
-              isRegistered: this.isRegistered()
-            });
-            break;
-          default:
-            break;
-        }
-      });
+      this.setupRegisterer();
       this.userAgent.delegate = {
         onInvite: (invite) => {
           this.callKit.logger.info("connect onInvite", {
@@ -18959,7 +19129,8 @@ var WebCall = (() => {
             caller: "Connect.register.onInvite",
             content: {
               invite,
-              isRegistered: this.isRegistered()
+              isRegistered: this.isRegistered(),
+              isOutgoing: this.isOutgoing
             }
           });
           this.currentSession = invite;
@@ -19037,7 +19208,9 @@ var WebCall = (() => {
             });
             this.callKit.logger.info("get invite data", {
               caller: "Connect.register.onInvite",
-              content: xHeaders
+              content: {
+                headers: xHeaders
+              }
             });
             return xHeaders;
           };
@@ -19058,9 +19231,16 @@ var WebCall = (() => {
           } catch (error) {
             this.callKit.logger.info(error, {
               caller: "Connect.register.onInvite",
-              content: info
+              content: {
+                headers: info
+              }
             });
           }
+          if (this.isRefering) {
+            this.currentSession.accept(options);
+            this.setRefering(false);
+            return;
+          }
           if (this.isOutgoing) {
             this.currentSession.accept(options);
             this.callKit.trigger(KitEvent.KIT_OUTGOING_INVITE, {
@@ -19096,9 +19276,8 @@ var WebCall = (() => {
               version: `${this.callKit.config.getConfig().version}`
             }
           });
-          await this.registerer.register().then(() => {
-            this.callKit.socket.send(SocketSendEvent.START);
-          }).catch(async (err) => {
+          this.setupRegisterer();
+          await this.registerer.register().catch(async (err) => {
             this.callKit.reset();
             this.callKit.logger.error(err?.message, {
               caller: "Connect.register",
@@ -19110,9 +19289,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,21 +19300,12 @@ 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: {}
             });
           }
-        },
-        onRegister: () => {
-          this.callKit.logger.info("connect onRegister", {
-            caller: "Connect.register",
-            type: "SIP",
-            content: {
-              version: `V${this.callKit.config.getConfig().version}`
-            }
-          });
         }
       };
       observeSocketStatus(this.userAgent, {
@@ -19182,6 +19351,7 @@ var WebCall = (() => {
       this.reconnectTimer = setTimeout(() => {
         if (this.reconnectTimer && this.callKit.config.isLogin()) {
           this.userAgent?.reconnect();
+          this.setIsReConnected(true);
           this.callKit.logger.info("Reconnect attempt", {
             caller: "Connect.startReconnectTimer",
             type: "SIP",
@@ -19226,14 +19396,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, {
@@ -19246,20 +19417,20 @@ var WebCall = (() => {
       });
     }
     async call(callback) {
-      this.callKit.logger.info("connect call", {
-        caller: "Connect.call",
-        type: "SIP",
-        content: {
-          callback
-        }
-      });
-      this.isOutgoing = true;
+      this.setOutgoing(true);
       if (!this.isRegistered()) {
         await this.register();
       }
       this.setConnectStatus(CallStatus.connecting);
       this.callKit.trigger(KitEvent.CALL_CONNECTING, /* @__PURE__ */ new Date());
       const { userInfo } = this.callKit.config.getConfig();
+      this.callKit.logger.info("connect call", {
+        caller: "Connect.call",
+        type: "SIP",
+        content: {
+          userInfo
+        }
+      });
       callback(userInfo);
     }
     /**
@@ -19267,6 +19438,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 +19481,7 @@ var WebCall = (() => {
           connectStatus: this.connectStatus
         }
       });
-      this.isOutgoing = false;
+      this.setOutgoing(false);
       this.isUnprompted = isUnprompted;
       this.setHold(false);
       this.setMute(false);
@@ -19336,6 +19509,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();
@@ -19462,12 +19636,26 @@ var WebCall = (() => {
       this.callKit.trigger(KitEvent.KIT_SET_MUTE, mute);
     }
     async refer(referTo, extra) {
+      if (!this.currentSession) {
+        const errorMsg = "Cannot refer: currentSession is not available";
+        this.callKit.logger.warn(errorMsg, {
+          caller: "Connect.refer",
+          type: "SIP",
+          content: {
+            errCode: ErrorCode.WEBRTC_CALL_INVITE_ERROR,
+            referTo
+          }
+        });
+        return;
+      }
+      this.setRefering(true);
       this.callKit.logger.info("connect refer", {
         caller: "Connect.refer",
         type: "SIP",
         content: {
           referTo,
-          extra
+          extra,
+          sessionState: this.currentSession.state
         }
       });
       let target;
@@ -19479,13 +19667,7 @@ var WebCall = (() => {
   };
 
   // core/socket.ts
-  var RECONNECT_CONFIG = {
-    enabled: true,
-    maxAttempts: 3,
-    delay: 1e3,
-    pingInterval: 3e4,
-    pingTimeout: 5e3
-  };
+  var EXCLUDE_LOG_EVENTS = [SocketReceiveEvent.WAITING_QUEUE];
   var Socket = class {
     callKit;
     ws;
@@ -19502,7 +19684,7 @@ var WebCall = (() => {
     /**
      * @description connect auth state
      * @default {
-     *   satrtConfirm: false,
+     *   startConfirm: false,
      *   isConnected: false,
      *   isReconnecting: false,
      *   isAuthenticated: false,
@@ -19510,14 +19692,13 @@ var WebCall = (() => {
      * }
      */
     connectAuthState = {
-      satrtConfirm: false,
+      startConfirm: false,
       isConnected: false,
       isReconnecting: false,
-      isAuthenticated: false,
       isError: false
     };
-    get satrtConfirm() {
-      return this.connectAuthState.satrtConfirm;
+    get startConfirm() {
+      return this.connectAuthState.startConfirm;
     }
     get isError() {
       return this.connectAuthState.isError;
@@ -19525,6 +19706,9 @@ var WebCall = (() => {
     constructor(callKit) {
       this.callKit = callKit;
     }
+    get reconnectConfig() {
+      return this.callKit.config.getReconnectConfig("incall");
+    }
     init() {
       const { socket } = this.callKit.config.getConfig();
       this.callKit.logger.info(`socket init: ${socket}`, {
@@ -19536,13 +19720,6 @@ var WebCall = (() => {
       });
       this.connect(socket);
     }
-    getSocketConfig() {
-      const { reconnect } = this.callKit.config.getConfig();
-      return {
-        ...RECONNECT_CONFIG,
-        ...reconnect
-      };
-    }
     setConnectAuthState(key, value) {
       if (this.connectAuthState[key] === value)
         return;
@@ -19550,7 +19727,7 @@ var WebCall = (() => {
     }
     handleDisconnect() {
       this.setConnectAuthState("isConnected", false);
-      const { enabled } = this.getSocketConfig();
+      const { enabled } = this.reconnectConfig;
       if (!this.callKit.config.isLogin() || !enabled) {
         this.callKit.reset();
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
@@ -19561,6 +19738,9 @@ var WebCall = (() => {
       if (this.connectAuthState.isReconnecting) {
         return;
       }
+      if (this.connectAuthState.isError) {
+        return;
+      }
       this.attemptReconnect();
     }
     clearWebSocket() {
@@ -19600,6 +19780,7 @@ var WebCall = (() => {
       this.setConnectAuthState("isConnected", true);
       this.lastPingTime = Date.now();
       this.checkPing();
+      this.send(SocketSendEvent.START);
       if (this.connectAuthState.isReconnecting) {
         this.setConnectAuthState("isReconnecting", false);
         this.callKit.logger.info("reconnect success", {
@@ -19615,19 +19796,31 @@ var WebCall = (() => {
         });
       }
     }
+    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 = {
-        satrtConfirm: false,
+        startConfirm: false,
         isConnected: false,
         isReconnecting: false,
-        isAuthenticated: false,
         isError: false
       };
-      this.reconnectAttempts = 0;
-      if (this.reconnectTimer) {
-        clearTimeout(this.reconnectTimer);
-        this.reconnectTimer = void 0;
-      }
+      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", {
@@ -19661,9 +19854,9 @@ var WebCall = (() => {
     }
     onMessage(ev) {
       const data = JSON.parse(ev.data);
-      let content = {};
+      let content = data.data;
       try {
-        if (data.data) {
+        if (typeof data.data === "string" && data.data) {
           content = JSON.parse(data.data);
         }
       } catch (error) {
@@ -19674,159 +19867,73 @@ var WebCall = (() => {
             data: data.data
           }
         });
-        content = data.data;
       }
-      this.callKit.logger.info("socket onMessage", {
-        caller: "Socket.onMessage",
-        type: "INCALL",
-        content: {
-          data: content,
-          event: data.event
-        }
-      });
-      this.confirmAck(data);
-      if (data.event === SocketReceiveEvent.PONG) {
-        this.lastPingTime = Date.now();
-        this.setConnectAuthState("isAuthenticated", true);
-        this.callKit.logger.info("socket onMessage pong Authenticated", {
+      if (!EXCLUDE_LOG_EVENTS.includes(data.event)) {
+        this.callKit.logger.info(`socket onMessage: ${data.event}`, {
           caller: "Socket.onMessage",
           type: "INCALL",
           content: {
             data: content,
-            event: SocketReceiveEvent.PONG,
-            isAuthenticated: true
+            event: data.event
           }
         });
-        this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
-          event: "INCALL_AUTHENTICATED",
-          isAuthenticated: true
-        });
+      }
+      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.setConnectAuthState("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.setConnectAuthState("isError", true);
@@ -19836,7 +19943,8 @@ var WebCall = (() => {
           type: "INCALL",
           content: {
             errCode: ErrorCode.SOKET_SERVER_ERROR,
-            data: content
+            data: content,
+            callUuid
           }
         });
       }
@@ -19848,24 +19956,29 @@ var WebCall = (() => {
           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
+        },
+        true
+      );
     }
     send(event, message) {
       if (!this.connectAuthState.isConnected) {
@@ -19913,32 +20026,18 @@ var WebCall = (() => {
         caller: "Socket.send",
         type: "INCALL",
         content: {
-          ...msg
+          ...msg,
+          userInfo
         }
       });
-      switch (event) {
-        case SocketSendEvent.PING:
-          this.lastPingTime = Date.now();
-          this.ws?.send(JSON.stringify({ event, ...msg }));
-          break;
-        default:
-          this.ws?.send(JSON.stringify({ event, ...msg }));
-          break;
-      }
+      this.ws?.send(JSON.stringify({ event, ...msg }));
     }
     ping() {
       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.getSocketConfig();
+      const { pingInterval, pingTimeout } = this.reconnectConfig;
       if (now - this.lastPingTime > pingInterval + pingTimeout) {
         if (this.ws && this.connectAuthState.isConnected) {
           this.ws.close(4001, "ping timeout");
@@ -19952,14 +20051,16 @@ var WebCall = (() => {
             errCode: ErrorCode.SOCKET_PING_TIMEOUT
           }
         });
+        this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
+          event: "INCALL_PING_TIMEOUT"
+        });
       }
     }
     checkPing() {
       if (this.pingTimer) {
         clearInterval(this.pingTimer);
       }
-      this.ping();
-      const { pingInterval } = this.getSocketConfig();
+      const { pingInterval } = this.reconnectConfig;
       this.pingTimer = setInterval(() => {
         this.ping();
       }, pingInterval);
@@ -19968,20 +20069,19 @@ var WebCall = (() => {
      * reset socket connection and all states
      */
     async reset(config) {
-      const { focus = false } = config || {};
+      const { force = false } = config || {};
       if (this.pingTimer) {
         clearInterval(this.pingTimer);
         this.pingTimer = void 0;
       }
-      if (focus) {
+      if (force) {
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_RESET"
         });
         this.resetConnectState();
-        this.setConnectAuthState("isConnected", false);
       }
       this.lastPingTime = void 0;
-      this.setConnectAuthState("satrtConfirm", false);
+      this.setConnectAuthState("startConfirm", false);
       this.clearWebSocket();
     }
     attemptReconnect() {
@@ -19989,11 +20089,12 @@ var WebCall = (() => {
         clearTimeout(this.reconnectTimer);
         this.reconnectTimer = void 0;
       }
-      const { maxAttempts } = this.getSocketConfig();
+      const { maxAttempts } = this.reconnectConfig;
       if (this.reconnectAttempts >= maxAttempts) {
         this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_RECONNECT_ERROR"
         });
+        this.setConnectAuthState("isError", true);
         this.callKit.reset();
         this.callKit.logger.error("Maximum reconnection attempts reached", {
           caller: "Socket.attemptReconnect",
@@ -20012,7 +20113,7 @@ var WebCall = (() => {
       }
       this.setConnectAuthState("isReconnecting", true);
       this.reconnectAttempts += 1;
-      const { delay } = this.getSocketConfig();
+      const { delay } = this.reconnectConfig;
       this.callKit.logger.info(
         `Preparing reconnection attempt ${this.reconnectAttempts}/${maxAttempts}, delay: ${delay}ms`,
         {
@@ -20047,17 +20148,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
@@ -20105,7 +20223,8 @@ var WebCall = (() => {
       try {
         const user = await this.api.login({
           userName: username,
-          password: encryptionPassword
+          password: encryptionPassword,
+          timestamp: Date.now()
         });
         if (user) {
           this.config.setConfig("userInfo", {
@@ -20151,7 +20270,7 @@ 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.warn(error, {
             caller: "CallKit.logout",
@@ -20163,8 +20282,9 @@ var WebCall = (() => {
       }
       if (isReset) {
         await this.reset();
+      } else {
+        this.config.reset("logout");
       }
-      this.trigger(KitEvent.KIT_LOGIN_CHANGE, false);
     }
     async call(extno = "", options = {
       sourceType: CallSourceType.phoneNum,
@@ -20297,7 +20417,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",
@@ -20308,16 +20428,24 @@ var WebCall = (() => {
       });
       await this.api.updateUserStatus({
         agentId,
-        userStatus: status
+        userStatus: status,
+        timestamp: Date.now(),
+        ...extra
       });
     }
-    async _reset(config) {
-      const { focus = false } = config || {};
+    /**
+     * 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,
-          focus
+          force
         }
       });
       if (this.connect.isCalling()) {
@@ -20326,16 +20454,10 @@ var WebCall = (() => {
       await this.connect.reset();
       if (this.config.isLogin()) {
         await this.logout({ isReset: false });
+      } else {
+        await this.config.reset("reset");
       }
-      await this.config.reset();
-      await this.socket.reset({ focus });
-    }
-    /**
-     * reset callkit
-     * @description recover the callkit to the initial state
-     */
-    async reset() {
-      await this._reset({ focus: true });
+      await this.socket.reset({ force });
     }
     on(event, callback) {
       this.listener.push({
@@ -20371,7 +20493,9 @@ var WebCall = (() => {
       if (!noLog) {
         this.logger.info(`Trigger Event: ${event}`, {
           caller: "CallKit.trigger",
-          content: data
+          content: {
+            data
+          }
         });
       }
       this.listener.forEach((item) => {
@@ -20379,7 +20503,7 @@ var WebCall = (() => {
           try {
             item.callback(data);
           } catch (err) {
-            this.logger.error("Event callback error:", err, true);
+            this.logger.error(`Event callback error: ${event}`, err, true);
           }
         }
       });