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

package/dist/index.global.js

@@ -3227,7 +3227,8 @@ var WebCall = (() => {
       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;
       }
@@ -3246,8 +3247,9 @@ var WebCall = (() => {
     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;
       }
@@ -3264,12 +3266,23 @@ var WebCall = (() => {
       }
     }
     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) {
+      }
     }
     /**
      *
@@ -3283,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}`;
@@ -3307,30 +3320,34 @@ var WebCall = (() => {
         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");
@@ -3340,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");
     }
@@ -3673,7 +3690,8 @@ var WebCall = (() => {
      * Error
      */
     ERROR: "ERROR",
-    SESSION_ERROR: "SESSION_ERROR"
+    SESSION_ERROR: "SESSION_ERROR",
+    WAITING_QUEUE: "WAITING_QUEUE"
   };
   var EncryptionMethod = {
     NONE: "NONE",
@@ -3696,7 +3714,7 @@ var WebCall = (() => {
   var trackLogsDefaultConfig = {
     enabled: false,
     interval: 5e3,
-    maxSize: 8192
+    maxSize: 4096
   };
   var SOCKET_RECONNECT_CONFIG = {
     enabled: true,
@@ -3708,9 +3726,7 @@ var WebCall = (() => {
   var SIP_RECONNECT_CONFIG = {
     enabled: true,
     maxAttempts: 3,
-    delay: 1e3,
-    enableMessageKeepalive: false,
-    messageKeepaliveInterval: 3e4
+    delay: 1e3
   };
 
   // core/call.ts
@@ -3854,13 +3870,13 @@ var WebCall = (() => {
   // 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"
@@ -3960,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: "",
@@ -4055,7 +4076,7 @@ var WebCall = (() => {
         this.flushTrackLogs();
       }, interval);
     }
-    flushTrackLogs() {
+    async flushTrackLogs() {
       if (this.pendingTrackLogs.length === 0) {
         return;
       }
@@ -4064,25 +4085,22 @@ 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 this.callKit.api.trackLogs(chunk);
           }
           this.pendingTrackLogs = [];
         } catch (error) {
@@ -4141,16 +4159,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);
       }
@@ -18576,7 +18600,6 @@ var WebCall = (() => {
   };
 
   // core/connect.ts
-  var MAX_HEARTBEAT_COUNT = 6;
   function convertObjectStringToJSON(input) {
     const corrected = input.replace(/(\w+):\s*'(.*?)'/g, '"$1": "$2"').replace(/'/g, '"');
     return corrected;
@@ -18631,6 +18654,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
@@ -18652,6 +18679,42 @@ var WebCall = (() => {
     }
     // 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",
@@ -18663,9 +18726,15 @@ var WebCall = (() => {
       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);
       }
@@ -18701,8 +18770,6 @@ var WebCall = (() => {
         }
       }
       this.setConnectStatus(CallStatus.init);
-      this.clearHeartbeat();
-      this.stopMessageKeepalive();
     }
     getAduioReference() {
       const { audioRef } = this.callKit.config.getConfig();
@@ -18767,73 +18834,6 @@ var WebCall = (() => {
     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;
@@ -18846,6 +18846,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()) {
@@ -18886,7 +19016,7 @@ var WebCall = (() => {
         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,
@@ -18904,9 +19034,7 @@ var WebCall = (() => {
           peerConnectionConfiguration: {
             iceServers: JSON.parse(convertObjectStringToJSON(iceInfo))
           }
-        },
-        authorizationUsername: fsUserId || userPart,
-        authorizationPassword: fsPassword
+        }
       };
       this.callKit.logger.info("connect connectConfig", {
         caller: "Connect.register",
@@ -18949,9 +19077,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",
@@ -18961,6 +19086,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);
@@ -18976,81 +19115,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.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", {
@@ -19058,7 +19123,8 @@ var WebCall = (() => {
             caller: "Connect.register.onInvite",
             content: {
               invite,
-              isRegistered: this.isRegistered()
+              isRegistered: this.isRegistered(),
+              isOutgoing: this.isOutgoing
             }
           });
           this.currentSession = invite;
@@ -19136,7 +19202,9 @@ var WebCall = (() => {
             });
             this.callKit.logger.info("get invite data", {
               caller: "Connect.register.onInvite",
-              content: xHeaders
+              content: {
+                headers: xHeaders
+              }
             });
             return xHeaders;
           };
@@ -19157,9 +19225,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, {
@@ -19195,10 +19270,8 @@ var WebCall = (() => {
               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",
@@ -19207,12 +19280,11 @@ var WebCall = (() => {
                 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: {
@@ -19222,21 +19294,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, {
@@ -19282,6 +19345,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",
@@ -19306,7 +19370,6 @@ var WebCall = (() => {
     }
     async stop() {
       await this.userAgent.stop();
-      this.stopMessageKeepalive();
     }
     async unregister() {
       this.callKit.logger.info("connect unregister", {
@@ -19316,7 +19379,6 @@ var WebCall = (() => {
           isRegistered: this.isRegistered()
         }
       });
-      this.stopMessageKeepalive();
       if (!this.isRegistered() || !this.registerer) {
         this.callKit.logger.warn("No registerer to unregister.", {
           caller: "Connect.unregister",
@@ -19349,20 +19411,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);
     }
     /**
@@ -19413,7 +19475,7 @@ var WebCall = (() => {
           connectStatus: this.connectStatus
         }
       });
-      this.isOutgoing = false;
+      this.setOutgoing(false);
       this.isUnprompted = isUnprompted;
       this.setHold(false);
       this.setMute(false);
@@ -19441,6 +19503,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();
@@ -19567,12 +19630,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;
@@ -19584,6 +19661,7 @@ var WebCall = (() => {
   };
 
   // core/socket.ts
+  var EXCLUDE_LOG_EVENTS = [SocketReceiveEvent.WAITING_QUEUE];
   var Socket = class {
     callKit;
     ws;
@@ -19770,9 +19848,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) {
@@ -19783,17 +19861,19 @@ var WebCall = (() => {
             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;
@@ -19803,32 +19883,51 @@ var WebCall = (() => {
         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);
@@ -19838,7 +19937,8 @@ var WebCall = (() => {
           type: "INCALL",
           content: {
             errCode: ErrorCode.SOKET_SERVER_ERROR,
-            data: content
+            data: content,
+            callUuid
           }
         });
       }
@@ -19850,21 +19950,29 @@ var WebCall = (() => {
           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) {
@@ -19912,18 +20020,11 @@ 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)
@@ -19944,13 +20045,15 @@ 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.reconnectConfig;
       this.pingTimer = setInterval(() => {
         this.ping();
@@ -19985,6 +20088,7 @@ var WebCall = (() => {
         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",
@@ -20113,7 +20217,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", {
@@ -20159,7 +20264,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",
@@ -20172,7 +20277,7 @@ var WebCall = (() => {
       if (isReset) {
         await this.reset();
       } else {
-        this.config.reset();
+        this.config.reset("logout");
       }
     }
     async call(extno = "", options = {
@@ -20306,7 +20411,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",
@@ -20317,7 +20422,9 @@ var WebCall = (() => {
       });
       await this.api.updateUserStatus({
         agentId,
-        userStatus: status
+        userStatus: status,
+        timestamp: Date.now(),
+        ...extra
       });
     }
     /**
@@ -20342,7 +20449,7 @@ var WebCall = (() => {
       if (this.config.isLogin()) {
         await this.logout({ isReset: false });
       } else {
-        await this.config.reset();
+        await this.config.reset("reset");
       }
       await this.socket.reset({ force });
     }
@@ -20380,7 +20487,9 @@ var WebCall = (() => {
       if (!noLog) {
         this.logger.info(`Trigger Event: ${event}`, {
           caller: "CallKit.trigger",
-          content: data
+          content: {
+            data
+          }
         });
       }
       this.listener.forEach((item) => {
@@ -20388,7 +20497,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);
           }
         }
       });