@stream-io/video-client 1.36.0 → 1.36.1

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [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 */
@@ -3929,19 +3929,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 +5976,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.36.0";
+const version = "1.36.1";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -6758,7 +6897,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 +6926,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 +7042,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 +7118,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 +7453,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 +7462,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 +7721,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 +7955,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({
@@ -12216,9 +12299,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 +12494,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 +12517,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 +14879,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.36.1", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),