@koi-design/callkit 2.3.0-beta.1 → 2.3.0-beta.10

package/dist/index.d.ts

@@ -5289,6 +5289,21 @@ declare class Connect {
     setMute(mute: boolean): Promise<void>;
     refer(referTo: string, extra?: any): Promise<void>;
     private referInCall;
+    /**
+     * Get the SIP URI for "refer to self" (same as reconnection refer logic).
+     * Shared by referInCallToSelf and internal reconnection refer.
+     */
+    private getSelfReferUri;
+    /**
+     * Whether we can refer the current call to self (has active session in Established/Establishing and is calling).
+     * Shared by reconnection logic and referInCallToSelf.
+     */
+    private canReferInCallToSelf;
+    /**
+     * Refer the current call to self (e.g. Agent RTP loss recovery, post-reconnect recovery).
+     * Socket and other callers can use this without constructing referTo.
+     */
+    referInCallToSelf(callUuid?: string, extra?: any): Promise<void>;
 }
 
 interface CallKitConfig {

package/dist/index.global.js

@@ -3700,7 +3700,11 @@ var WebCall = (() => {
     ERROR: "ERROR",
     SESSION_ERROR: "SESSION_ERROR",
     WAITING_QUEUE: "WAITING_QUEUE",
-    CUSTOMER_MATCH_BLACK_PHONE: "CUSTOMER_MATCH_BLACK_PHONE"
+    CUSTOMER_MATCH_BLACK_PHONE: "CUSTOMER_MATCH_BLACK_PHONE",
+    /**
+     * Agent RTP loss
+     */
+    AGENT_RTP_LOSS: "AGENT_RTP_LOSS"
   };
   var EncryptionMethod = {
     NONE: "NONE",
@@ -3889,7 +3893,7 @@ var WebCall = (() => {
   // package.json
   var package_default = {
     name: "@koi-design/callkit",
-    version: "2.3.0-beta.1",
+    version: "2.3.0-beta.10",
     description: "callkit",
     author: "koi",
     license: "ISC",
@@ -18989,8 +18993,6 @@ ${log}` : log;
         });
         return;
       }
-      const { userInfo } = this.callKit.config.getConfig();
-      const { userPart, fsIp, fsPort } = userInfo;
       const { registererOptions = {} } = this.reconnectConfig;
       this.registerer = new Registerer(this.userAgent, registererOptions);
       this.registerer.stateChange.addListener((state) => {
@@ -19024,27 +19026,26 @@ ${log}` : log;
             });
             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}`;
+              if (this.canReferInCallToSelf()) {
                 this.callKit.logger.info(
                   "Reconnected, referring active session to self",
                   {
                     caller: "Connect.setupRegisterer.registererStateChange",
                     type: "SIP",
                     content: {
-                      selfUri,
+                      selfUri: this.getSelfReferUri(),
                       sessionState: this.currentSession.state,
                       connectStatus: this.connectStatus
                     }
                   }
                 );
-                this.referInCall(selfUri).catch((err) => {
+                this.referInCallToSelf().catch((err) => {
                   this.callKit.logger.error(err, {
                     caller: "Connect.setupRegisterer.registererStateChange",
                     type: "SIP",
                     content: {
                       errCode: ErrorCode.WEBRTC_CALL_INVITE_ERROR,
-                      selfUri
+                      selfUri: this.getSelfReferUri()
                     }
                   });
                 });
@@ -19873,6 +19874,59 @@ ${log}` : log;
       }
       this.currentSession.refer(target, extra?.sessionReferOptions);
     }
+    /**
+     * Get the SIP URI for "refer to self" (same as reconnection refer logic).
+     * Shared by referInCallToSelf and internal reconnection refer.
+     */
+    getSelfReferUri() {
+      const { userInfo } = this.callKit.config.getConfig();
+      const { userPart, fsIp, fsPort } = userInfo;
+      return `sip:manualCallAgent${userPart}@${fsIp}:${fsPort}`;
+    }
+    /**
+     * Whether we can refer the current call to self (has active session in Established/Establishing and is calling).
+     * Shared by reconnection logic and referInCallToSelf.
+     */
+    canReferInCallToSelf() {
+      return !!this.currentSession && (this.currentSession.state === SessionState2.Established || this.currentSession.state === SessionState2.Establishing) && this.isCalling();
+    }
+    /**
+     * Refer the current call to self (e.g. Agent RTP loss recovery, post-reconnect recovery).
+     * Socket and other callers can use this without constructing referTo.
+     */
+    async referInCallToSelf(callUuid, extra) {
+      if (callUuid && this.currentCallId !== callUuid) {
+        this.callKit.logger.warn(
+          "Cannot refer in call to self: callUuid mismatch",
+          {
+            caller: "Connect.referInCallToSelf",
+            type: "SIP",
+            content: {
+              currentCallId: this.currentCallId,
+              callUuid
+            }
+          }
+        );
+        return;
+      }
+      if (!this.canReferInCallToSelf()) {
+        this.callKit.logger.warn(
+          "Cannot refer in call to self: preconditions not met",
+          {
+            caller: "Connect.referInCallToSelf",
+            type: "SIP",
+            content: {
+              hasCurrentSession: !!this.currentSession,
+              sessionState: this.currentSession?.state,
+              isCalling: this.isCalling()
+            }
+          }
+        );
+        return;
+      }
+      const selfUri = this.getSelfReferUri();
+      return this.referInCall(selfUri, extra);
+    }
   };
 
   // core/socket.ts
@@ -20098,6 +20152,28 @@ ${log}` : log;
         this.setConnectAuthState("startConfirm", true);
         this.cleanReconnectState();
       }
+      if (data.event === SocketReceiveEvent.AGENT_RTP_LOSS) {
+        this.callKit.logger.warn("Agent RTP loss", {
+          caller: "Socket.onMessage",
+          type: "INCALL",
+          content: {
+            data: {
+              callUuid,
+              ...content
+            },
+            event: SocketReceiveEvent.AGENT_RTP_LOSS
+          }
+        });
+        if (callUuid) {
+          this.callKit.connect.referInCallToSelf(callUuid).catch((err) => {
+            this.callKit.logger.error(err, {
+              caller: "Socket.onMessage:AGENT_RTP_LOSS",
+              type: "INCALL",
+              content: { callUuid, event: SocketReceiveEvent.AGENT_RTP_LOSS }
+            });
+          });
+        }
+      }
       if (data.event === SocketReceiveEvent.CUSTOMER_RINGING) {
         this.callKit.trigger(KitEvent.CALL_RINGING, {
           time: /* @__PURE__ */ new Date(),
@@ -20210,7 +20286,7 @@ ${log}` : log;
         return;
       }
       const { userInfo, version } = this.callKit.config.getConfig();
-      const { sessionId, extno, agentId, phoneType } = userInfo;
+      const { sessionId, extno, agentId } = userInfo;
       if (!sessionId) {
         this.callKit.logger.error("sessionId is empty", {
           caller: "Socket.send",
@@ -20230,7 +20306,6 @@ ${log}` : log;
       if (SocketSendEvent.CALL === event) {
         msg.phoneNum = extno;
         msg.agentId = agentId;
-        msg.phoneType = phoneType;
         if (message?.sourceType === CallSourceType.phoneNum) {
           delete msg.workOrderId;
         } else if (message?.sourceType === CallSourceType.workOrderId) {
@@ -20550,7 +20625,10 @@ ${log}` : log;
         caller: "CallKit.register",
         content: {}
       });
-      this.connect.register();
+      const { userInfo } = this.config.getConfig();
+      if (userInfo.phoneType === PhoneTypeEnum.SIP) {
+        this.connect.register();
+      }
     }
     async unregister() {
       if (!this.config.check())
@@ -20660,10 +20738,13 @@ ${log}` : log;
           force
         }
       });
-      if (this.connect.isCalling()) {
-        await this.hangup();
+      const { userInfo } = this.config.getConfig();
+      if (userInfo.phoneType === PhoneTypeEnum.SIP) {
+        if (this.connect.isCalling()) {
+          await this.hangup();
+        }
+        await this.connect.reset({ force });
       }
-      await this.connect.reset({ force });
       if (this.config.isLogin()) {
         await this.logout({ isReset: false });
       } else {