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

package/dist/index.mjs

@@ -27,6 +27,11 @@ var Api = class {
   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;
@@ -36,15 +41,18 @@ var Api = class {
         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;
@@ -54,20 +62,29 @@ var Api = class {
         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) {
+    }
   }
   /**
    *
@@ -81,7 +98,7 @@ var Api = class {
       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}`;
@@ -104,11 +121,37 @@ var Api = class {
     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;
@@ -116,7 +159,7 @@ var Api = class {
       return data;
     }
     if (code === "100013") {
-      this.callKit.config.reset();
+      this.callKit.config.reset("api request error");
     }
     throw new Error(message ?? "Request failed");
   }
@@ -429,6 +472,10 @@ var SocketReceiveEvent = {
    * Agent no answer
    */
   AGENT_NO_ANSWER: "AGENT_NO_ANSWER",
+  /**
+   * Agent hang up
+   */
+  AGENT_HANG_UP: "AGENT_HANG_UP",
   /**
    * Call detail record push
    */
@@ -445,7 +492,8 @@ var SocketReceiveEvent = {
    * Error
    */
   ERROR: "ERROR",
-  SESSION_ERROR: "SESSION_ERROR"
+  SESSION_ERROR: "SESSION_ERROR",
+  WAITING_QUEUE: "WAITING_QUEUE"
 };
 var EncryptionMethod = {
   NONE: "NONE",
@@ -468,7 +516,19 @@ var CallSourceType = {
 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
@@ -483,14 +543,14 @@ var Call = class {
     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;
@@ -612,14 +672,14 @@ var Call = class {
 // 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"
   },
@@ -676,6 +736,10 @@ var Config = class {
     audioRef: void 0,
     constrains: constrainsDefault,
     socket: "",
+    reconnect: {
+      sip: SIP_RECONNECT_CONFIG,
+      incall: SOCKET_RECONNECT_CONFIG
+    },
     userInfo: {
       wsUrl: "",
       logGather: false,
@@ -714,7 +778,12 @@ var Config = class {
       }
     });
   };
-  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: "",
@@ -760,7 +829,16 @@ var Config = class {
     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;
@@ -800,7 +878,7 @@ var Logger = class {
       this.flushTrackLogs();
     }, interval);
   }
-  flushTrackLogs() {
+  async flushTrackLogs() {
     if (this.pendingTrackLogs.length === 0) {
       return;
     }
@@ -809,26 +887,29 @@ var Logger = class {
       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);
@@ -886,16 +967,22 @@ var Logger = class {
   }
   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);
     }
@@ -929,11 +1016,6 @@ var formatGetInviteData = (inviteData) => {
 };
 
 // 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;
@@ -964,10 +1046,6 @@ var initUserMedia = () => {
 };
 var Connect = class {
   callKit;
-  /**
-   *@description  Reconnect config
-   */
-  reconnectConfig;
   /**
    *@description  Whether muted
    */
@@ -992,6 +1070,10 @@ var Connect = class {
    *@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
@@ -1007,14 +1089,48 @@ var Connect = class {
   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",
@@ -1026,6 +1142,15 @@ var Connect = class {
     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);
     }
@@ -1045,9 +1170,6 @@ var Connect = class {
     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);
@@ -1064,7 +1186,6 @@ var Connect = class {
       }
     }
     this.setConnectStatus(CallStatus.init);
-    this.clearHeartbeat();
   }
   getAduioReference() {
     const { audioRef } = this.callKit.config.getConfig();
@@ -1129,28 +1250,6 @@ var Connect = class {
   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;
@@ -1163,6 +1262,136 @@ var Connect = class {
     });
     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 === SessionState.Established || this.currentSession.state === SessionState.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()) {
@@ -1264,9 +1493,6 @@ var Connect = class {
       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",
@@ -1276,6 +1502,20 @@ var Connect = class {
         });
         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);
@@ -1291,77 +1531,7 @@ var Connect = class {
         };
       }
     };
-    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", {
@@ -1369,7 +1539,8 @@ var Connect = class {
           caller: "Connect.register.onInvite",
           content: {
             invite,
-            isRegistered: this.isRegistered()
+            isRegistered: this.isRegistered(),
+            isOutgoing: this.isOutgoing
           }
         });
         this.currentSession = invite;
@@ -1447,7 +1618,9 @@ var Connect = class {
           });
           this.callKit.logger.info("get invite data", {
             caller: "Connect.register.onInvite",
-            content: xHeaders
+            content: {
+              headers: xHeaders
+            }
           });
           return xHeaders;
         };
@@ -1468,9 +1641,16 @@ var Connect = class {
         } 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, {
@@ -1506,9 +1686,8 @@ var Connect = class {
             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",
@@ -1520,9 +1699,8 @@ var Connect = class {
         });
       },
       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: {
@@ -1532,21 +1710,12 @@ var Connect = class {
           });
           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, {
@@ -1592,6 +1761,7 @@ var Connect = class {
     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",
@@ -1636,14 +1806,15 @@ var Connect = class {
       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, {
@@ -1656,20 +1827,20 @@ var Connect = class {
     });
   }
   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);
   }
   /**
@@ -1677,6 +1848,8 @@ var Connect = class {
    * @param register
    */
   setRegister(register) {
+    if (this.isRegister === register)
+      return;
     this.callKit.logger.info("connect setRegister", {
       caller: "Connect.setRegister",
       type: "SIP",
@@ -1718,7 +1891,7 @@ var Connect = class {
         connectStatus: this.connectStatus
       }
     });
-    this.isOutgoing = false;
+    this.setOutgoing(false);
     this.isUnprompted = isUnprompted;
     this.setHold(false);
     this.setMute(false);
@@ -1746,6 +1919,7 @@ var Connect = class {
       }
       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();
@@ -1872,12 +2046,26 @@ var Connect = class {
     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;
@@ -1889,13 +2077,7 @@ var Connect = class {
 };
 
 // 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;
@@ -1912,7 +2094,7 @@ var Socket = class {
   /**
    * @description connect auth state
    * @default {
-   *   satrtConfirm: false,
+   *   startConfirm: false,
    *   isConnected: false,
    *   isReconnecting: false,
    *   isAuthenticated: false,
@@ -1920,14 +2102,13 @@ var Socket = class {
    * }
    */
   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;
@@ -1935,6 +2116,9 @@ var Socket = class {
   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}`, {
@@ -1946,13 +2130,6 @@ var Socket = class {
     });
     this.connect(socket);
   }
-  getSocketConfig() {
-    const { reconnect } = this.callKit.config.getConfig();
-    return {
-      ...RECONNECT_CONFIG,
-      ...reconnect
-    };
-  }
   setConnectAuthState(key, value) {
     if (this.connectAuthState[key] === value)
       return;
@@ -1960,7 +2137,7 @@ var Socket = class {
   }
   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, {
@@ -1971,6 +2148,9 @@ var Socket = class {
     if (this.connectAuthState.isReconnecting) {
       return;
     }
+    if (this.connectAuthState.isError) {
+      return;
+    }
     this.attemptReconnect();
   }
   clearWebSocket() {
@@ -2010,6 +2190,7 @@ var Socket = class {
     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", {
@@ -2025,19 +2206,31 @@ var Socket = class {
       });
     }
   }
+  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", {
@@ -2071,9 +2264,9 @@ var Socket = class {
   }
   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) {
@@ -2084,159 +2277,73 @@ var Socket = class {
           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);
@@ -2246,7 +2353,8 @@ var Socket = class {
         type: "INCALL",
         content: {
           errCode: ErrorCode.SOKET_SERVER_ERROR,
-          data: content
+          data: content,
+          callUuid
         }
       });
     }
@@ -2258,24 +2366,29 @@ var Socket = class {
         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) {
@@ -2323,32 +2436,18 @@ var Socket = class {
       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");
@@ -2362,14 +2461,16 @@ var Socket = class {
           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);
@@ -2378,20 +2479,19 @@ var Socket = class {
    * 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() {
@@ -2399,11 +2499,12 @@ var Socket = class {
       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",
@@ -2422,7 +2523,7 @@ var Socket = class {
     }
     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`,
       {
@@ -2457,17 +2558,34 @@ var CallKit = class {
     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
@@ -2515,7 +2633,8 @@ var CallKit = class {
     try {
       const user = await this.api.login({
         userName: username,
-        password: encryptionPassword
+        password: encryptionPassword,
+        timestamp: Date.now()
       });
       if (user) {
         this.config.setConfig("userInfo", {
@@ -2561,7 +2680,7 @@ var CallKit = class {
     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",
@@ -2573,8 +2692,9 @@ var CallKit = class {
     }
     if (isReset) {
       await this.reset();
+    } else {
+      this.config.reset("logout");
     }
-    this.trigger(KitEvent.KIT_LOGIN_CHANGE, false);
   }
   async call(extno = "", options = {
     sourceType: CallSourceType.phoneNum,
@@ -2707,7 +2827,7 @@ var CallKit = class {
    * set userstatus
    * @param status
    */
-  async setUserStatus(status) {
+  async setUserStatus(status, extra = {}) {
     const { agentId } = this.config.getConfig().userInfo;
     this.logger.info("setUserStatus", {
       caller: "CallKit.setUserStatus",
@@ -2718,16 +2838,24 @@ var CallKit = class {
     });
     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()) {
@@ -2736,16 +2864,10 @@ var CallKit = class {
     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({
@@ -2781,7 +2903,9 @@ var CallKit = class {
     if (!noLog) {
       this.logger.info(`Trigger Event: ${event}`, {
         caller: "CallKit.trigger",
-        content: data
+        content: {
+          data
+        }
       });
     }
     this.listener.forEach((item) => {
@@ -2789,7 +2913,7 @@ var CallKit = class {
         try {
           item.callback(data);
         } catch (err) {
-          this.logger.error("Event callback error:", err, true);
+          this.logger.error(`Event callback error: ${event}`, err, true);
         }
       }
     });