@stream-io/video-client 1.36.0 → 1.37.0

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [1.37.0](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.36.1...@stream-io/video-client-1.37.0) (2025-11-14)
+
+### Features
+
+- ring individual members ([#1755](https://github.com/GetStream/stream-video-js/issues/1755)) ([57564d6](https://github.com/GetStream/stream-video-js/commit/57564d63f21da7b95b582f74c88b24af7e77659c))
+
+## [1.36.1](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.36.0...@stream-io/video-client-1.36.1) (2025-11-12)
+
+- enforce the client to publish options on SDP level ([#1976](https://github.com/GetStream/stream-video-js/issues/1976)) ([1d93f72](https://github.com/GetStream/stream-video-js/commit/1d93f72cb4395aaf9b487eb66e0c3b6a8111aca4))
+
 ## [1.36.0](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.35.1...@stream-io/video-client-1.36.0) (2025-10-30)
 
 ### Features

package/dist/index.browser.es.js

@@ -6,9 +6,9 @@ export { AxiosError } from 'axios';
 import { TwirpFetchTransport, TwirpErrorCode } from '@protobuf-ts/twirp-transport';
 import * as scopedLogger from '@stream-io/logger';
 export { LogLevelEnum } from '@stream-io/logger';
+import { parse, write } from 'sdp-transform';
 import { ReplaySubject, combineLatest, BehaviorSubject, shareReplay, map, distinctUntilChanged, startWith, takeWhile, distinctUntilKeyChanged, fromEventPattern, concatMap, merge, from, fromEvent, tap, debounceTime, pairwise, of } from 'rxjs';
 import { UAParser } from 'ua-parser-js';
-import { parse, write } from 'sdp-transform';
 import { WorkerTimer } from '@stream-io/worker-timer';
 
 /* tslint:disable */
@@ -52,7 +52,6 @@ const FrameRecordingSettingsRequestQualityEnum = {
     _720P: '720p',
     _1080P: '1080p',
     _1440P: '1440p',
-    _2160P: '2160p',
 };
 /**
  * @export
@@ -148,13 +147,11 @@ const RTMPBroadcastRequestQualityEnum = {
     _720P: '720p',
     _1080P: '1080p',
     _1440P: '1440p',
-    _2160P: '2160p',
     PORTRAIT_360X640: 'portrait-360x640',
     PORTRAIT_480X854: 'portrait-480x854',
     PORTRAIT_720X1280: 'portrait-720x1280',
     PORTRAIT_1080X1920: 'portrait-1080x1920',
     PORTRAIT_1440X2560: 'portrait-1440x2560',
-    PORTRAIT_2160X3840: 'portrait-2160x3840',
 };
 /**
  * @export
@@ -165,13 +162,11 @@ const RTMPSettingsRequestQualityEnum = {
     _720P: '720p',
     _1080P: '1080p',
     _1440P: '1440p',
-    _2160P: '2160p',
     PORTRAIT_360X640: 'portrait-360x640',
     PORTRAIT_480X854: 'portrait-480x854',
     PORTRAIT_720X1280: 'portrait-720x1280',
     PORTRAIT_1080X1920: 'portrait-1080x1920',
     PORTRAIT_1440X2560: 'portrait-1440x2560',
-    PORTRAIT_2160X3840: 'portrait-2160x3840',
 };
 /**
  * @export
@@ -190,13 +185,11 @@ const RecordSettingsRequestQualityEnum = {
     _720P: '720p',
     _1080P: '1080p',
     _1440P: '1440p',
-    _2160P: '2160p',
     PORTRAIT_360X640: 'portrait-360x640',
     PORTRAIT_480X854: 'portrait-480x854',
     PORTRAIT_720X1280: 'portrait-720x1280',
     PORTRAIT_1080X1920: 'portrait-1080x1920',
     PORTRAIT_1440X2560: 'portrait-1440x2560',
-    PORTRAIT_2160X3840: 'portrait-2160x3840',
 };
 /**
  * @export
@@ -3929,19 +3922,158 @@ const retryable = async (rpc, signal) => {
     return result;
 };
 
+/**
+ * Extracts the mid from the transceiver or the SDP.
+ *
+ * @param transceiver the transceiver.
+ * @param transceiverInitIndex the index of the transceiver in the transceiver's init array.
+ * @param sdp the SDP.
+ */
+const extractMid = (transceiver, transceiverInitIndex, sdp) => {
+    if (transceiver.mid)
+        return transceiver.mid;
+    if (!sdp)
+        return String(transceiverInitIndex);
+    const track = transceiver.sender.track;
+    const parsedSdp = parse(sdp);
+    const media = parsedSdp.media.find((m) => {
+        return (m.type === track.kind &&
+            // if `msid` is not present, we assume that the track is the first one
+            (m.msid?.includes(track.id) ?? true));
+    });
+    if (typeof media?.mid !== 'undefined')
+        return String(media.mid);
+    if (transceiverInitIndex < 0)
+        return '';
+    return String(transceiverInitIndex);
+};
+/**
+ * Enables stereo in the answer SDP based on the offered stereo in the offer SDP.
+ *
+ * @param offerSdp the offer SDP containing the stereo configuration.
+ * @param answerSdp the answer SDP to be modified.
+ */
+const enableStereo = (offerSdp, answerSdp) => {
+    const offeredStereoMids = new Set();
+    const parsedOfferSdp = parse(offerSdp);
+    for (const media of parsedOfferSdp.media) {
+        if (media.type !== 'audio')
+            continue;
+        const opus = media.rtp.find((r) => r.codec === 'opus');
+        if (!opus)
+            continue;
+        for (const fmtp of media.fmtp) {
+            if (fmtp.payload === opus.payload && fmtp.config.includes('stereo=1')) {
+                offeredStereoMids.add(media.mid);
+            }
+        }
+    }
+    // No stereo offered, return the original answerSdp
+    if (offeredStereoMids.size === 0)
+        return answerSdp;
+    const parsedAnswerSdp = parse(answerSdp);
+    for (const media of parsedAnswerSdp.media) {
+        if (media.type !== 'audio' || !offeredStereoMids.has(media.mid))
+            continue;
+        const opus = media.rtp.find((r) => r.codec === 'opus');
+        if (!opus)
+            continue;
+        for (const fmtp of media.fmtp) {
+            if (fmtp.payload === opus.payload && !fmtp.config.includes('stereo=1')) {
+                fmtp.config += ';stereo=1';
+            }
+        }
+    }
+    return write(parsedAnswerSdp);
+};
+/**
+ * Removes all codecs from the SDP except the specified codec.
+ *
+ * @param sdp the SDP to modify.
+ * @param codecMimeTypeToKeep the codec mime type to keep (video/h264 or audio/opus).
+ * @param fmtpProfileToKeep the fmtp profile to keep (e.g. 'profile-level-id=42e01f' or multiple segments like 'profile-level-id=64001f;packetization-mode=1').
+ */
+const removeCodecsExcept = (sdp, codecMimeTypeToKeep, fmtpProfileToKeep) => {
+    const [kind, codec] = toMimeType(codecMimeTypeToKeep).split('/');
+    if (!kind || !codec)
+        return sdp;
+    const parsed = parse(sdp);
+    for (const media of parsed.media) {
+        if (media.type !== kind)
+            continue;
+        // Build a set of payloads to KEEP: all payloads whose rtp.codec matches codec
+        let payloadsToKeep = new Set();
+        for (const rtp of media.rtp) {
+            if (rtp.codec.toLowerCase() !== codec)
+                continue;
+            payloadsToKeep.add(rtp.payload);
+        }
+        // If a specific fmtp profile is requested, only keep payloads whose fmtp config matches it
+        if (fmtpProfileToKeep) {
+            const filtered = new Set();
+            const required = new Set(fmtpProfileToKeep.split(';'));
+            for (const fmtp of media.fmtp) {
+                if (payloadsToKeep.has(fmtp.payload) &&
+                    required.difference(new Set(fmtp.config.split(';'))).size === 0) {
+                    filtered.add(fmtp.payload);
+                }
+            }
+            payloadsToKeep = filtered;
+        }
+        // If no payloads to keep AND no fmtpProfile was specified, skip modifications (preserve SDP as-is)
+        if (payloadsToKeep.size === 0 && !fmtpProfileToKeep)
+            continue;
+        // Keep RTX payloads that are associated with kept primary payloads via apt
+        // RTX mappings look like: a=fmtp:<rtxPayload> apt=<primaryPayload>
+        for (const fmtp of media.fmtp) {
+            const matches = /\s*apt\s*=\s*(\d+)\s*/i.exec(fmtp.config);
+            if (!matches)
+                continue;
+            const primaryPayloadApt = Number(matches[1]);
+            if (!payloadsToKeep.has(primaryPayloadApt))
+                continue;
+            payloadsToKeep.add(fmtp.payload);
+        }
+        // Filter rtp, fmtp and rtcpFb entries
+        media.rtp = media.rtp.filter((rtp) => payloadsToKeep.has(rtp.payload));
+        media.fmtp = media.fmtp.filter((fmtp) => payloadsToKeep.has(fmtp.payload));
+        media.rtcpFb = media.rtcpFb?.filter((fb) => typeof fb.payload === 'number' ? payloadsToKeep.has(fb.payload) : true);
+        // Update the m= line payload list to only the kept payloads, preserving original order
+        const payloads = [];
+        for (const id of (media.payloads || '').split(/\s+/)) {
+            const payload = Number(id);
+            if (!payloadsToKeep.has(payload))
+                continue;
+            payloads.push(payload);
+        }
+        media.payloads = payloads.join(' ');
+    }
+    return write(parsed);
+};
+/**
+ * Converts the given codec to a mime-type format when necessary.
+ * e.g.: `vp9` -> `video/vp9`
+ */
+const toMimeType = (codec, kind = 'video') => codec.includes('/') ? codec : `${kind}/${codec}`;
+
 /**
  * Returns a generic SDP for the given direction.
  * We use this SDP to send it as part of our JoinRequest so that the SFU
  * can use it to determine the client's codec capabilities.
  *
  * @param direction the direction of the transceiver.
+ * @param codecToKeep the codec mime type to keep (video/h264 or audio/opus).
+ * @param fmtpProfileToKeep optional fmtp profile to keep.
  */
-const getGenericSdp = async (direction) => {
+const getGenericSdp = async (direction, codecToKeep, fmtpProfileToKeep) => {
     const tempPc = new RTCPeerConnection();
     tempPc.addTransceiver('video', { direction });
     tempPc.addTransceiver('audio', { direction });
     const offer = await tempPc.createOffer();
-    const sdp = offer.sdp ?? '';
+    const { sdp: baseSdp = '' } = offer;
+    const sdp = codecToKeep
+        ? removeCodecsExcept(baseSdp, codecToKeep, fmtpProfileToKeep)
+        : baseSdp;
     tempPc.getTransceivers().forEach((t) => {
         t.stop?.();
     });
@@ -5837,7 +5969,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.36.0";
+const version = "1.37.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -6758,7 +6890,7 @@ class BasePeerConnection {
     /**
      * Constructs a new `BasePeerConnection` instance.
      */
-    constructor(peerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, tag, enableTracing, iceRestartDelay = 2500, }) {
+    constructor(peerType, { sfuClient, connectionConfig, state, dispatcher, onReconnectionNeeded, tag, enableTracing, clientPublishOptions, iceRestartDelay = 2500, }) {
         this.isIceRestarting = false;
         this.isDisposed = false;
         this.trackIdToTrackType = new Map();
@@ -6787,7 +6919,7 @@ class BasePeerConnection {
                     e.error.code === ErrorCode.PARTICIPANT_SIGNAL_LOST
                     ? WebsocketReconnectStrategy.FAST
                     : WebsocketReconnectStrategy.REJOIN;
-                this.onReconnectionNeeded?.(strategy, reason);
+                this.onReconnectionNeeded?.(strategy, reason, this.peerType);
             });
         };
         /**
@@ -6903,7 +7035,7 @@ class BasePeerConnection {
             }
             // we can't recover from a failed connection state (contrary to ICE)
             if (state === 'failed') {
-                this.onReconnectionNeeded?.(WebsocketReconnectStrategy.REJOIN, 'Connection failed');
+                this.onReconnectionNeeded?.(WebsocketReconnectStrategy.REJOIN, 'Connection failed', this.peerType);
                 return;
             }
             this.handleConnectionStateUpdate(state);
@@ -6979,6 +7111,7 @@ class BasePeerConnection {
         this.state = state;
         this.dispatcher = dispatcher;
         this.iceRestartDelay = iceRestartDelay;
+        this.clientPublishOptions = clientPublishOptions;
         this.onReconnectionNeeded = onReconnectionNeeded;
         this.logger = videoLoggerSystem.getLogger(peerType === PeerType.SUBSCRIBER ? 'Subscriber' : 'Publisher', { tags: [tag] });
         this.pc = this.createPeerConnection(connectionConfig);
@@ -7313,71 +7446,6 @@ const withSimulcastConstraints = (width, height, optimalVideoLayers, useSingleLa
     }));
 };
 
-/**
- * Extracts the mid from the transceiver or the SDP.
- *
- * @param transceiver the transceiver.
- * @param transceiverInitIndex the index of the transceiver in the transceiver's init array.
- * @param sdp the SDP.
- */
-const extractMid = (transceiver, transceiverInitIndex, sdp) => {
-    if (transceiver.mid)
-        return transceiver.mid;
-    if (!sdp)
-        return String(transceiverInitIndex);
-    const track = transceiver.sender.track;
-    const parsedSdp = parse(sdp);
-    const media = parsedSdp.media.find((m) => {
-        return (m.type === track.kind &&
-            // if `msid` is not present, we assume that the track is the first one
-            (m.msid?.includes(track.id) ?? true));
-    });
-    if (typeof media?.mid !== 'undefined')
-        return String(media.mid);
-    if (transceiverInitIndex < 0)
-        return '';
-    return String(transceiverInitIndex);
-};
-/**
- * Enables stereo in the answer SDP based on the offered stereo in the offer SDP.
- *
- * @param offerSdp the offer SDP containing the stereo configuration.
- * @param answerSdp the answer SDP to be modified.
- */
-const enableStereo = (offerSdp, answerSdp) => {
-    const offeredStereoMids = new Set();
-    const parsedOfferSdp = parse(offerSdp);
-    for (const media of parsedOfferSdp.media) {
-        if (media.type !== 'audio')
-            continue;
-        const opus = media.rtp.find((r) => r.codec === 'opus');
-        if (!opus)
-            continue;
-        for (const fmtp of media.fmtp) {
-            if (fmtp.payload === opus.payload && fmtp.config.includes('stereo=1')) {
-                offeredStereoMids.add(media.mid);
-            }
-        }
-    }
-    // No stereo offered, return the original answerSdp
-    if (offeredStereoMids.size === 0)
-        return answerSdp;
-    const parsedAnswerSdp = parse(answerSdp);
-    for (const media of parsedAnswerSdp.media) {
-        if (media.type !== 'audio' || !offeredStereoMids.has(media.mid))
-            continue;
-        const opus = media.rtp.find((r) => r.codec === 'opus');
-        if (!opus)
-            continue;
-        for (const fmtp of media.fmtp) {
-            if (fmtp.payload === opus.payload && !fmtp.config.includes('stereo=1')) {
-                fmtp.config += ';stereo=1';
-            }
-        }
-    }
-    return write(parsedAnswerSdp);
-};
-
 /**
  * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
  *
@@ -7387,7 +7455,7 @@ class Publisher extends BasePeerConnection {
     /**
      * Constructs a new `Publisher` instance.
      */
-    constructor({ publishOptions, ...baseOptions }) {
+    constructor(baseOptions, publishOptions) {
         super(PeerType.PUBLISHER_UNSPECIFIED, baseOptions);
         this.transceiverCache = new TransceiverCache();
         this.clonedTracks = new Set();
@@ -7646,7 +7714,11 @@ class Publisher extends BasePeerConnection {
                 try {
                     this.isIceRestarting = options?.iceRestart ?? false;
                     await this.pc.setLocalDescription(offer);
-                    const { sdp = '' } = offer;
+                    const { sdp: baseSdp = '' } = offer;
+                    const { dangerouslyForceCodec, fmtpLine } = this.clientPublishOptions || {};
+                    const sdp = dangerouslyForceCodec
+                        ? removeCodecsExcept(baseSdp, dangerouslyForceCodec, fmtpLine)
+                        : baseSdp;
                     const { response } = await this.sfuClient.setPublisher({ sdp, tracks });
                     if (response.error)
                         throw new NegotiationError(response.error);
@@ -7876,6 +7948,10 @@ class Subscriber extends BasePeerConnection {
             const answer = await this.pc.createAnswer();
             if (answer.sdp) {
                 answer.sdp = enableStereo(subscriberOffer.sdp, answer.sdp);
+                const { dangerouslyForceCodec, subscriberFmtpLine } = this.clientPublishOptions || {};
+                if (dangerouslyForceCodec) {
+                    answer.sdp = removeCodecsExcept(answer.sdp, dangerouslyForceCodec, subscriberFmtpLine);
+                }
             }
             await this.pc.setLocalDescription(answer);
             await this.sfuClient.sendAnswer({
@@ -12022,6 +12098,7 @@ class Call {
          * @param params.ring if set to true, a `call.ring` event will be sent to the call members.
          * @param params.notify if set to true, a `call.notification` event will be sent to the call members.
          * @param params.members_limit the total number of members to return as part of the response.
+         * @param params.video if set to true, in a ringing scenario, mobile SDKs will show "incoming video call", audio only otherwise.
          */
         this.get = async (params) => {
             await this.setup();
@@ -12075,11 +12152,11 @@ class Call {
             return this.streamClient.post(`${this.streamClientBasePath}/delete`, data);
         };
         /**
-         * A shortcut for {@link Call.get} with `ring` parameter set to `true`.
-         * Will send a `call.ring` event to the call members.
+         * Sends a ring notification to the provided users who are not already in the call.
+         * All users should be members of the call.
          */
-        this.ring = async () => {
-            return await this.get({ ring: true });
+        this.ring = async (data = {}) => {
+            return this.streamClient.post(`${this.streamClientBasePath}/ring`, data);
         };
         /**
          * A shortcut for {@link Call.get} with `notify` parameter set to `true`.
@@ -12216,9 +12293,10 @@ class Call {
                 // prepare a generic SDP and send it to the SFU.
                 // these are throw-away SDPs that the SFU will use to determine
                 // the capabilities of the client (codec support, etc.)
+                const { dangerouslyForceCodec, fmtpLine, subscriberFmtpLine } = this.clientPublishOptions || {};
                 const [subscriberSdp, publisherSdp] = await Promise.all([
-                    getGenericSdp('recvonly'),
-                    getGenericSdp('sendonly'),
+                    getGenericSdp('recvonly', dangerouslyForceCodec, subscriberFmtpLine),
+                    getGenericSdp('sendonly', dangerouslyForceCodec, fmtpLine),
                 ]);
                 const isReconnecting = this.reconnectStrategy !== WebsocketReconnectStrategy.UNSPECIFIED;
                 const reconnectDetails = isReconnecting
@@ -12410,20 +12488,22 @@ class Call {
             if (closePreviousInstances && this.subscriber) {
                 this.subscriber.dispose();
             }
-            this.subscriber = new Subscriber({
+            const basePeerConnectionOptions = {
                 sfuClient,
                 dispatcher: this.dispatcher,
                 state: this.state,
                 connectionConfig,
                 tag: sfuClient.tag,
                 enableTracing,
-                onReconnectionNeeded: (kind, reason) => {
+                clientPublishOptions: this.clientPublishOptions,
+                onReconnectionNeeded: (kind, reason, peerType) => {
                     this.reconnect(kind, reason).catch((err) => {
-                        const message = `[Reconnect] Error reconnecting after a subscriber error: ${reason}`;
+                        const message = `[Reconnect] Error reconnecting, after a ${PeerType[peerType]} error: ${reason}`;
                         this.logger.warn(message, err);
                     });
                 },
-            });
+            };
+            this.subscriber = new Subscriber(basePeerConnectionOptions);
             // anonymous users can't publish anything hence, there is no need
             // to create Publisher Peer Connection for them
             const isAnonymous = this.streamClient.user?.type === 'anonymous';
@@ -12431,21 +12511,7 @@ class Call {
                 if (closePreviousInstances && this.publisher) {
                     this.publisher.dispose();
                 }
-                this.publisher = new Publisher({
-                    sfuClient,
-                    dispatcher: this.dispatcher,
-                    state: this.state,
-                    connectionConfig,
-                    publishOptions,
-                    tag: sfuClient.tag,
-                    enableTracing,
-                    onReconnectionNeeded: (kind, reason) => {
-                        this.reconnect(kind, reason).catch((err) => {
-                            const message = `[Reconnect] Error reconnecting after a publisher error: ${reason}`;
-                            this.logger.warn(message, err);
-                        });
-                    },
-                });
+                this.publisher = new Publisher(basePeerConnectionOptions, publishOptions);
             }
             this.statsReporter?.stop();
             if (this.statsReportingIntervalInMs > 0) {
@@ -14807,7 +14873,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.36.0", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.37.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -15027,10 +15093,6 @@ class StreamVideoClient {
          * @param e the event.
          */
         this.initCallFromEvent = async (e) => {
-            if (this.state.connectedUser?.id === e.call.created_by.id) {
-                this.logger.debug(`Ignoring ${e.type} event sent by the current user`);
-                return;
-            }
             try {
                 const concurrencyTag = getCallInitConcurrencyTag(e.call_cid);
                 await withoutConcurrency(concurrencyTag, async () => {
@@ -15344,12 +15406,12 @@ class StreamVideoClient {
         this.shouldRejectCall = (currentCallId) => {
             if (!this.rejectCallWhenBusy)
                 return false;
-            const hasOngoingRingingCall = this.state.calls.some((c) => c.cid !== currentCallId &&
+            return this.state.calls.some((c) => c.cid !== currentCallId &&
                 c.ringing &&
+                !c.isCreatedByMe &&
                 c.state.callingState !== CallingState.IDLE &&
                 c.state.callingState !== CallingState.LEFT &&
                 c.state.callingState !== CallingState.RECONNECTING_FAILED);
-            return hasOngoingRingingCall;
         };
         const apiKey = typeof apiKeyOrArgs === 'string' ? apiKeyOrArgs : apiKeyOrArgs.apiKey;
         const clientOptions = typeof apiKeyOrArgs === 'string' ? opts : apiKeyOrArgs.options;