arnacon-webrtc-service 0.1.113 → 0.1.115

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arnacon-webrtc-service",
-  "version": "0.1.113",
+  "version": "0.1.115",
   "description": "Arnacon WebRTC core runtime and service modules",
   "main": "./webRTCservice/core.js",
   "type": "commonjs",

package/webRTCservice/modules/openAiSipGateway.js

@@ -378,6 +378,7 @@ function createOpenAiSipGateway({
                 sessionId: call.sessionId,
                 callId: call.callId,
                 openAiCallId: call.openAiCallId || null,
+                mode: call.mode || "default",
                 phase: session.phase || null,
                 established: Boolean(call.established),
             };

package/webRTCservice/modules/peerConnection.js

@@ -139,65 +139,69 @@ function patchRouterForDynamicSsrc(pc, logger = console) {
     if (!router || router._ssrcPatchApplied) return false;
     const origRouteRtp = router.routeRtp.bind(router);
     router._rtpInCount = 0;
+    router._inboundRtpSubscribers = router._inboundRtpSubscribers || new Set();
     router._ssrcPatchApplied = true;
     router.routeRtp = (packet) => {
         router._rtpInCount++;
         const incomingSsrc = packet.header.ssrc;
         if (router.ssrcTable && router.ssrcTable[incomingSsrc]) {
             origRouteRtp(packet);
-            return;
-        }
-        const recvs = pc.getReceivers ? pc.getReceivers() : [];
-        for (const recv of recvs) {
-            const bySsrc = recv.trackBySSRC || {};
-            if (bySsrc[incomingSsrc]) break;
-
-            const tracks = recv.tracks || [];
-            if (tracks.length === 1) {
-                // Keep using the already-created track object so existing RTP subscriptions survive.
-                const existingTrack = tracks[0];
-                const oldSsrc = existingTrack.ssrc;
-                const oldNum = Number(oldSsrc);
-                const canLateBind =
-                    !Number.isFinite(oldNum) ||
-                    oldNum <= 0 ||
-                    oldNum === 1;
-                if (!canLateBind) {
-                    continue;
-                }
-                if (oldSsrc !== incomingSsrc) {
-                    if (router.ssrcTable) {
-                        delete router.ssrcTable[oldSsrc];
-                        router.ssrcTable[incomingSsrc] = recv;
+        } else {
+            const recvs = pc.getReceivers ? pc.getReceivers() : [];
+            for (const recv of recvs) {
+                const bySsrc = recv.trackBySSRC || {};
+                if (bySsrc[incomingSsrc]) break;
+
+                const tracks = recv.tracks || [];
+                if (tracks.length === 1) {
+                    // Keep using the already-created track object so existing RTP subscriptions survive.
+                    const existingTrack = tracks[0];
+                    const oldSsrc = existingTrack.ssrc;
+                    const oldNum = Number(oldSsrc);
+                    const canLateBind =
+                        !Number.isFinite(oldNum) ||
+                        oldNum <= 0 ||
+                        oldNum === 1;
+                    if (!canLateBind) {
+                        continue;
                     }
-                    if (recv.trackBySSRC && recv.trackBySSRC[oldSsrc] === existingTrack) {
-                        delete recv.trackBySSRC[oldSsrc];
+                    if (oldSsrc !== incomingSsrc) {
+                        if (router.ssrcTable) {
+                            delete router.ssrcTable[oldSsrc];
+                            router.ssrcTable[incomingSsrc] = recv;
+                        }
+                        if (recv.trackBySSRC && recv.trackBySSRC[oldSsrc] === existingTrack) {
+                            delete recv.trackBySSRC[oldSsrc];
+                        }
+                        existingTrack.ssrc = incomingSsrc;
+                        if (recv.trackBySSRC) recv.trackBySSRC[incomingSsrc] = existingTrack;
+                        logger.log(`[SSRC-FIX] Rebound existing track: ssrc ${oldSsrc} -> ${incomingSsrc}`);
                     }
-                    existingTrack.ssrc = incomingSsrc;
-                    if (recv.trackBySSRC) recv.trackBySSRC[incomingSsrc] = existingTrack;
-                    logger.log(`[SSRC-FIX] Rebound existing track: ssrc ${oldSsrc} -> ${incomingSsrc}`);
+                    break;
                 }
-                break;
-            }
 
-            // Legacy placeholder behavior: receivers that start with SSRC=1.
-            if (tracks.length > 0 && tracks.every((t) => t.ssrc === 1)) {
-                const existingTrack = recv.trackBySSRC?.[1];
-                if (existingTrack) {
-                    const oldSsrc = 1;
-                    if (router.ssrcTable) {
-                        delete router.ssrcTable[oldSsrc];
-                        router.ssrcTable[incomingSsrc] = recv;
+                // Legacy placeholder behavior: receivers that start with SSRC=1.
+                if (tracks.length > 0 && tracks.every((t) => t.ssrc === 1)) {
+                    const existingTrack = recv.trackBySSRC?.[1];
+                    if (existingTrack) {
+                        const oldSsrc = 1;
+                        if (router.ssrcTable) {
+                            delete router.ssrcTable[oldSsrc];
+                            router.ssrcTable[incomingSsrc] = recv;
+                        }
+                        existingTrack.ssrc = incomingSsrc;
+                        delete recv.trackBySSRC[oldSsrc];
+                        recv.trackBySSRC[incomingSsrc] = existingTrack;
+                        logger.log(`[SSRC-FIX] Rebound existing track: ssrc ${oldSsrc} -> ${incomingSsrc}`);
+                        break;
                     }
-                    existingTrack.ssrc = incomingSsrc;
-                    delete recv.trackBySSRC[oldSsrc];
-                    recv.trackBySSRC[incomingSsrc] = existingTrack;
-                    logger.log(`[SSRC-FIX] Rebound existing track: ssrc ${oldSsrc} -> ${incomingSsrc}`);
-                    break;
                 }
             }
+            origRouteRtp(packet);
+        }
+        for (const fn of router._inboundRtpSubscribers || []) {
+            try { fn(packet); } catch (_) {}
         }
-        origRouteRtp(packet);
     };
     logger.log("[SSRC-FIX] Router patched for late SSRC binding");
     return true;
@@ -306,6 +310,9 @@ function createPeerConnectionFactory({
         let clientToKamTranscoded = 0;
         let kamToClientTranscoded = 0;
         let kamUnsubscribe = null;
+        let kamTrackPackets = 0;
+        let kamRouterFallbackPackets = 0;
+        let lastKamTrackRtpAt = 0;
 
         if (pc1 && session.sipLocalAudioTrack) {
             for (const t of pc1.getTransceivers()) {
@@ -329,6 +336,8 @@ function createPeerConnectionFactory({
 
         const kamHandler = (rtp) => {
             if (!session.mediaRelayActive) return;
+            kamTrackPackets++;
+            lastKamTrackRtpAt = Date.now();
             if (!Number.isFinite(sipPayloadType)) sipPayloadType = Number(rtp?.header?.payloadType);
             if (!kamSourceNotified && session.localAudioTrack) {
                 kamSourceNotified = true;
@@ -345,6 +354,27 @@ function createPeerConnectionFactory({
             }
         };
 
+        const kamRouterFallbackHandler = (rtp) => {
+            if (!session.mediaRelayActive || !session.localAudioTrack || !rtp?.header) return;
+            // werift can keep counting inbound RTP while a receiver track subscription
+            // stops firing after late SSRC binding. Use router packets only when the
+            // normal track path has gone quiet, to avoid duplicate audio.
+            if (lastKamTrackRtpAt && Date.now() - lastKamTrackRtpAt < 500) return;
+            if (!Number.isFinite(sipPayloadType)) sipPayloadType = Number(rtp.header.payloadType);
+            if (!kamSourceNotified) {
+                kamSourceNotified = true;
+                session.localAudioTrack.onSourceChanged.execute({
+                    sequenceNumber: rtp.header.sequenceNumber,
+                    timestamp: rtp.header.timestamp,
+                });
+            }
+            const outgoing = adaptG711RtpPacket(rtp, clientPayloadType);
+            if (outgoing !== rtp) kamToClientTranscoded++;
+            kamRouterFallbackPackets++;
+            kamToClient++;
+            session.localAudioTrack.writeRtp(outgoing);
+        };
+
         const subscribeKamTrack = (track) => {
             if (!track || track.kind !== "audio" || !session.localAudioTrack || !session.mediaRelayActive) return;
             if (kamUnsubscribe) {
@@ -373,6 +403,12 @@ function createPeerConnectionFactory({
             pc2.onTrack.subscribe((track) => {
                 if (track.kind === "audio") subscribeKamTrack(track);
             });
+            if (pc2.router?._inboundRtpSubscribers) {
+                pc2.router._inboundRtpSubscribers.add(kamRouterFallbackHandler);
+                session._relayDisposers.push(() => {
+                    try { pc2.router._inboundRtpSubscribers.delete(kamRouterFallbackHandler); } catch (_) {}
+                });
+            }
         }
         // Temporary diagnostics: verify whether RTP is flowing both directions.
         // Remove after media-path issue is resolved.
@@ -383,6 +419,7 @@ function createPeerConnectionFactory({
                 `[${sessionId}] RTP-STATS pc1_in=${pc1RtpIn} pc2_in=${pc2RtpIn} client_to_kam=${clientToKam} kam_to_client=${kamToClient} ` +
                 `client_pt=${clientPayloadType ?? "?"} sip_pt=${sipPayloadType ?? "?"} ` +
                 `c2k_xcode=${clientToKamTranscoded} k2c_xcode=${kamToClientTranscoded} ` +
+                `kam_track=${kamTrackPackets} kam_fallback=${kamRouterFallbackPackets} ` +
                 `pc2_present=${!!pc2} kam_pipe_active=${kamPipeActive}`
             );
         }, 2000);

package/webRTCservice/modules/signalingHandlers.js

@@ -51,6 +51,12 @@ function createSignalingHandlers({
             const payload = msg.payload;
 
             if (action === "end-call" && payload) {
+                if (sess && sess.phase === "ringing") {
+                    handleEndCallRenegotiation(sessionId, payload).catch((err) => {
+                        logger.error(`[${sessionId}] Immediate end-call failed: ${err.message}`);
+                    });
+                    return;
+                }
                 enqueueSignaling(sessionId, "end-call", () => handleEndCallRenegotiation(sessionId, payload));
                 return;
             }
@@ -84,10 +90,22 @@ function createSignalingHandlers({
         if (msgType === "call") {
             const action = msg.action;
             if (action === "end") {
+                if (sess && sess.phase === "ringing") {
+                    handleCallEnd(sessionId, "client-initiated").catch((err) => {
+                        logger.error(`[${sessionId}] Immediate call-end failed: ${err.message}`);
+                    });
+                    return;
+                }
                 enqueueSignaling(sessionId, "call-end", () => handleCallEnd(sessionId, "client-initiated"));
                 return;
             }
             if (action === "reject") {
+                if (sess && sess.phase === "ringing") {
+                    handleCallEnd(sessionId, "client-reject").catch((err) => {
+                        logger.error(`[${sessionId}] Immediate call-reject failed: ${err.message}`);
+                    });
+                    return;
+                }
                 enqueueSignaling(sessionId, "call-reject", () => handleCallEnd(sessionId, "client-reject"));
                 return;
             }