@koi-design/callkit 2.0.6-beta.1 → 2.1.0-beta.2

package/dist/index.mjs

@@ -29,7 +29,8 @@ var Api = class {
     if (this.isLogining) {
       this.callKit.logger.info("login is already in progress cancel", {
         caller: "Api.login",
-        content: { userName: params.userName }
+        type: "API",
+        content: { userName: params.userName, timestamp: params.timestamp }
       });
       return;
     }
@@ -48,8 +49,9 @@ var Api = class {
   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 }
+        content: { sessionId: params.sessionId, timestamp: params.timestamp }
       });
       return;
     }
@@ -66,12 +68,23 @@ var Api = class {
     }
   }
   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) {
+    }
   }
   /**
    *
@@ -85,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}`;
@@ -109,30 +122,34 @@ var Api = class {
       config.headers.sessionId = sessionId;
     }
     const startTime = Date.now();
-    this.callKit.logger.info("API Request Start", {
-      type: "API",
-      caller: "API.Request",
-      content: {
-        url: config.url,
-        headers: config.headers,
-        data: config.data,
-        extra,
-        startTime
-      }
-    });
+    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();
-    this.callKit.logger.info("API Request Finish", {
-      type: "API",
-      caller: "API.Request",
-      content: {
-        url: config.url,
-        duration: `${endTime - startTime}ms`,
-        response: res
-      }
-    });
+    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.reset();
       throw new Error("Network error");
@@ -142,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");
   }
@@ -475,7 +492,8 @@ var SocketReceiveEvent = {
    * Error
    */
   ERROR: "ERROR",
-  SESSION_ERROR: "SESSION_ERROR"
+  SESSION_ERROR: "SESSION_ERROR",
+  WAITING_QUEUE: "WAITING_QUEUE"
 };
 var EncryptionMethod = {
   NONE: "NONE",
@@ -498,7 +516,7 @@ var CallSourceType = {
 var trackLogsDefaultConfig = {
   enabled: false,
   interval: 5e3,
-  maxSize: 8192
+  maxSize: 4096
 };
 var SOCKET_RECONNECT_CONFIG = {
   enabled: true,
@@ -510,9 +528,7 @@ var SOCKET_RECONNECT_CONFIG = {
 var SIP_RECONNECT_CONFIG = {
   enabled: true,
   maxAttempts: 3,
-  delay: 1e3,
-  enableMessageKeepalive: false,
-  messageKeepaliveInterval: 3e4
+  delay: 1e3
 };
 
 // core/call.ts
@@ -656,13 +672,13 @@ var Call = class {
 // package.json
 var package_default = {
   name: "@koi-design/callkit",
-  version: "2.0.6-beta.1",
+  version: "2.1.0-beta.2",
   description: "callkit",
   author: "koi",
   license: "ISC",
   scripts: {
     build: "tsup",
-    sraet: "vite",
+    start: "vite",
     dev: "tsup --watch",
     lint: "eslint -c ../../.eslintrc.js --ext .jsx,.js,.tsx,.ts ./package --fix",
     release: "tsup && node scripts/pkg.js"
@@ -762,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: "",
@@ -857,7 +878,7 @@ var Logger = class {
       this.flushTrackLogs();
     }, interval);
   }
-  flushTrackLogs() {
+  async flushTrackLogs() {
     if (this.pendingTrackLogs.length === 0) {
       return;
     }
@@ -866,25 +887,22 @@ 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 this.callKit.api.trackLogs(chunk);
         }
         this.pendingTrackLogs = [];
       } catch (error) {
@@ -943,16 +961,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);
     }
@@ -967,8 +991,7 @@ import {
   Web,
   Registerer,
   SessionState,
-  RegistererState,
-  Messager
+  RegistererState
 } from "sip.js";
 
 // core/utils.ts
@@ -987,7 +1010,6 @@ var formatGetInviteData = (inviteData) => {
 };
 
 // core/connect.ts
-var MAX_HEARTBEAT_COUNT = 6;
 function convertObjectStringToJSON(input) {
   const corrected = input.replace(/(\w+):\s*'(.*?)'/g, '"$1": "$2"').replace(/'/g, '"');
   return corrected;
@@ -1042,6 +1064,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
@@ -1063,6 +1089,42 @@ var Connect = class {
   }
   // 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",
@@ -1074,9 +1136,15 @@ var Connect = class {
     this.callKit.trigger(KitEvent.KIT_CALL_ID_CHANGE, callId);
   }
   async reset() {
-    this.isOutgoing = false;
+    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);
     }
@@ -1112,8 +1180,6 @@ var Connect = class {
       }
     }
     this.setConnectStatus(CallStatus.init);
-    this.clearHeartbeat();
-    this.stopMessageKeepalive();
   }
   getAduioReference() {
     const { audioRef } = this.callKit.config.getConfig();
@@ -1178,73 +1244,6 @@ var Connect = class {
   isInit() {
     return this.connectStatus === CallStatus.init;
   }
-  heartbeatInterval;
-  heartbeatFlag = MAX_HEARTBEAT_COUNT;
-  messageKeepaliveTimer;
-  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);
-  }
-  stopMessageKeepalive() {
-    if (this.messageKeepaliveTimer) {
-      clearInterval(this.messageKeepaliveTimer);
-      this.messageKeepaliveTimer = void 0;
-    }
-  }
-  startMessageKeepalive() {
-    const { enableMessageKeepalive, messageKeepaliveInterval } = this.reconnectConfig;
-    if (!enableMessageKeepalive)
-      return;
-    this.stopMessageKeepalive();
-    this.messageKeepaliveTimer = setInterval(() => {
-      this.sendKeepaliveMessage();
-    }, messageKeepaliveInterval);
-  }
-  async sendKeepaliveMessage() {
-    try {
-      if (!this.isRegistered() || !this.userAgent)
-        return;
-      const { userInfo } = this.callKit.config.getConfig();
-      const { userPart, fsIp, fsPort } = userInfo || {};
-      const target = UserAgent.makeURI(`sip:${userPart}@${fsIp}:${fsPort}`);
-      if (!target)
-        return;
-      const messager = new Messager(this.userAgent, target, "");
-      await messager.message();
-      this.callKit.logger.info("MESSAGE keepalive ok", {
-        caller: "Connect.sendKeepaliveMessage",
-        type: "SIP",
-        content: {}
-      });
-    } catch (err) {
-      this.callKit.logger.error(err, {
-        caller: "Connect.sendKeepaliveMessage",
-        type: "SIP",
-        content: {}
-      });
-      this.stopMessageKeepalive();
-      this.callKit.trigger(KitEvent.SIP_CONNECT_EVENT, {
-        event: "MESSAGE_KEEPALIVE_FAILED"
-      });
-      this.startReconnectTimer();
-    }
-  }
   socketTriggerHangup(callId) {
     if (!this.isCalling() || callId !== this.currentCallId)
       return;
@@ -1257,6 +1256,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()) {
@@ -1297,7 +1426,7 @@ var Connect = class {
       this.mediaStream = await navigator.mediaDevices.getUserMedia(constrains);
       return this.mediaStream;
     };
-    const { userPart, fsIp, fsPort, iceInfo, wsUrl, fsUserId, fsPassword } = userInfo;
+    const { userPart, fsIp, fsPort, iceInfo, wsUrl } = userInfo;
     const connectConfig = {
       uri: UserAgent.makeURI(`sip:${userPart}@${fsIp}:${fsPort}`),
       displayName: userPart,
@@ -1315,9 +1444,7 @@ var Connect = class {
         peerConnectionConfiguration: {
           iceServers: JSON.parse(convertObjectStringToJSON(iceInfo))
         }
-      },
-      authorizationUsername: fsUserId || userPart,
-      authorizationPassword: fsPassword
+      }
     };
     this.callKit.logger.info("connect connectConfig", {
       caller: "Connect.register",
@@ -1360,9 +1487,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",
@@ -1372,6 +1496,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);
@@ -1387,81 +1525,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.stopMessageKeepalive();
-          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.startMessageKeepalive();
-          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.stopMessageKeepalive();
-          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.stopMessageKeepalive();
-          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", {
@@ -1469,7 +1533,8 @@ var Connect = class {
           caller: "Connect.register.onInvite",
           content: {
             invite,
-            isRegistered: this.isRegistered()
+            isRegistered: this.isRegistered(),
+            isOutgoing: this.isOutgoing
           }
         });
         this.currentSession = invite;
@@ -1547,7 +1612,9 @@ var Connect = class {
           });
           this.callKit.logger.info("get invite data", {
             caller: "Connect.register.onInvite",
-            content: xHeaders
+            content: {
+              headers: xHeaders
+            }
           });
           return xHeaders;
         };
@@ -1568,9 +1635,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, {
@@ -1606,10 +1680,8 @@ var Connect = class {
             version: `${this.callKit.config.getConfig().version}`
           }
         });
-        try {
-          await this.registerer.register();
-          this.startMessageKeepalive();
-        } catch (err) {
+        this.setupRegisterer();
+        await this.registerer.register().catch(async (err) => {
           this.callKit.reset();
           this.callKit.logger.error(err?.message, {
             caller: "Connect.register",
@@ -1618,12 +1690,11 @@ var Connect = class {
               errCode: ErrorCode.WEBRTC_REGISTER_ERROR
             }
           });
-        }
+        });
       },
       onDisconnect: (error) => {
-        this.stopMessageKeepalive();
         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: {
@@ -1633,21 +1704,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, {
@@ -1693,6 +1755,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",
@@ -1717,7 +1780,6 @@ var Connect = class {
   }
   async stop() {
     await this.userAgent.stop();
-    this.stopMessageKeepalive();
   }
   async unregister() {
     this.callKit.logger.info("connect unregister", {
@@ -1727,7 +1789,6 @@ var Connect = class {
         isRegistered: this.isRegistered()
       }
     });
-    this.stopMessageKeepalive();
     if (!this.isRegistered() || !this.registerer) {
       this.callKit.logger.warn("No registerer to unregister.", {
         caller: "Connect.unregister",
@@ -1760,20 +1821,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);
   }
   /**
@@ -1824,7 +1885,7 @@ var Connect = class {
         connectStatus: this.connectStatus
       }
     });
-    this.isOutgoing = false;
+    this.setOutgoing(false);
     this.isUnprompted = isUnprompted;
     this.setHold(false);
     this.setMute(false);
@@ -1852,6 +1913,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();
@@ -1978,12 +2040,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;
@@ -1995,6 +2071,7 @@ var Connect = class {
 };
 
 // core/socket.ts
+var EXCLUDE_LOG_EVENTS = [SocketReceiveEvent.WAITING_QUEUE];
 var Socket = class {
   callKit;
   ws;
@@ -2181,9 +2258,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) {
@@ -2194,17 +2271,19 @@ var Socket = class {
           data: data.data
         }
       });
-      content = data.data;
     }
-    this.callKit.logger.info(`socket onMessage: ${data.event}`, {
-      caller: "Socket.onMessage",
-      type: "INCALL",
-      content: {
-        data: content,
-        event: data.event
-      }
-    });
+    if (!EXCLUDE_LOG_EVENTS.includes(data.event)) {
+      this.callKit.logger.info(`socket onMessage: ${data.event}`, {
+        caller: "Socket.onMessage",
+        type: "INCALL",
+        content: {
+          data: content,
+          event: data.event
+        }
+      });
+    }
     this.confirmAck(data);
+    const callUuid = content?.callUuid || "";
     if (data.event === SocketReceiveEvent.PONG) {
       this.lastPingTime = Date.now();
       return;
@@ -2214,32 +2293,51 @@ var Socket = class {
       this.cleanReconnectState();
     }
     if (data.event === SocketReceiveEvent.CUSTOMER_RINGING) {
-      this.callKit.trigger(KitEvent.CALL_RINGING, /* @__PURE__ */ new Date());
+      this.callKit.trigger(KitEvent.CALL_RINGING, {
+        time: /* @__PURE__ */ new Date(),
+        callUuid
+      });
     }
     if (data.event === SocketReceiveEvent.CUSTOMER_PICK_UP) {
-      this.callKit.trigger(KitEvent.CALL_PICK_UP, /* @__PURE__ */ new Date());
+      this.callKit.trigger(KitEvent.CALL_PICK_UP, {
+        time: /* @__PURE__ */ new Date(),
+        callUuid
+      });
     }
     if (data.event === SocketReceiveEvent.AGENT_PICK_UP) {
-      this.callKit.trigger(KitEvent.AGENT_PICK_UP, /* @__PURE__ */ new Date());
+      this.callKit.trigger(KitEvent.AGENT_PICK_UP, {
+        time: /* @__PURE__ */ new Date(),
+        callUuid
+      });
     }
     if (data.event === SocketReceiveEvent.CUSTOMER_HANG_UP) {
-      this.callKit.trigger(KitEvent.CALL_HANG_UP, /* @__PURE__ */ new Date());
-      if (content?.callUuid) {
-        this.callKit.connect.socketTriggerHangup(content.callUuid);
+      this.callKit.trigger(KitEvent.CALL_HANG_UP, {
+        time: /* @__PURE__ */ new Date(),
+        callUuid
+      });
+      if (callUuid) {
+        this.callKit.connect.socketTriggerHangup(callUuid);
       }
     }
     if (data.event === SocketReceiveEvent.CUSTOMER_NO_ANSWER) {
-      this.callKit.trigger(KitEvent.CALL_NO_ANSWER);
-      if (content?.callUuid) {
-        this.callKit.connect.socketTriggerHangup(content.callUuid);
+      this.callKit.trigger(KitEvent.CALL_NO_ANSWER, {
+        time: /* @__PURE__ */ new Date(),
+        callUuid
+      });
+      if (callUuid) {
+        this.callKit.connect.socketTriggerHangup(callUuid);
       }
     }
     if (data.event === SocketReceiveEvent.CALL_CDR) {
-      this.callKit.trigger(KitEvent.CALL_CDR, content);
+      this.callKit.trigger(KitEvent.CALL_CDR, {
+        time: /* @__PURE__ */ new Date(),
+        callUuid,
+        ...content
+      });
     }
     if (data.event === SocketReceiveEvent.CLOSE) {
       const { userInfo } = this.callKit.config.getConfig();
-      this.send(SocketSendEvent.END, { agentId: userInfo.agentId });
+      this.send(SocketSendEvent.END, { agentId: userInfo.agentId, callUuid });
     }
     if (data.event === SocketReceiveEvent.ERROR) {
       this.setConnectAuthState("isError", true);
@@ -2249,7 +2347,8 @@ var Socket = class {
         type: "INCALL",
         content: {
           errCode: ErrorCode.SOKET_SERVER_ERROR,
-          data: content
+          data: content,
+          callUuid
         }
       });
     }
@@ -2261,21 +2360,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) {
-      if (content?.callUuid) {
-        this.callKit.connect.socketTriggerHangup(content.callUuid);
+      if (callUuid) {
+        this.callKit.connect.socketTriggerHangup(callUuid);
       }
     }
     if (data.event === SocketReceiveEvent.AGENT_HANG_UP) {
-      if (content?.callUuid) {
-        this.callKit.connect.socketTriggerHangup(content.callUuid);
+      if (callUuid) {
+        this.callKit.connect.socketTriggerHangup(callUuid);
       }
     }
-    this.callKit.trigger(KitEvent.SERVER_SOCKET_EVENT, data);
+    this.callKit.trigger(
+      KitEvent.SERVER_SOCKET_EVENT,
+      {
+        ...data,
+        callUuid
+      },
+      true
+    );
   }
   send(event, message) {
     if (!this.connectAuthState.isConnected) {
@@ -2323,18 +2430,11 @@ 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)
@@ -2355,13 +2455,15 @@ 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.reconnectConfig;
     this.pingTimer = setInterval(() => {
       this.ping();
@@ -2396,6 +2498,7 @@ var Socket = class {
       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",
@@ -2524,7 +2627,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", {
@@ -2570,7 +2674,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",
@@ -2583,7 +2687,7 @@ var CallKit = class {
     if (isReset) {
       await this.reset();
     } else {
-      this.config.reset();
+      this.config.reset("logout");
     }
   }
   async call(extno = "", options = {
@@ -2717,7 +2821,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",
@@ -2728,7 +2832,9 @@ var CallKit = class {
     });
     await this.api.updateUserStatus({
       agentId,
-      userStatus: status
+      userStatus: status,
+      timestamp: Date.now(),
+      ...extra
     });
   }
   /**
@@ -2753,7 +2859,7 @@ var CallKit = class {
     if (this.config.isLogin()) {
       await this.logout({ isReset: false });
     } else {
-      await this.config.reset();
+      await this.config.reset("reset");
     }
     await this.socket.reset({ force });
   }
@@ -2791,7 +2897,9 @@ var CallKit = class {
     if (!noLog) {
       this.logger.info(`Trigger Event: ${event}`, {
         caller: "CallKit.trigger",
-        content: data
+        content: {
+          data
+        }
       });
     }
     this.listener.forEach((item) => {
@@ -2799,7 +2907,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);
         }
       }
     });