@stream-io/video-client 1.59.1 → 1.61.0

package/src/ringing/reconcileRingState.ts

@@ -0,0 +1,108 @@
+import type { Call } from '../Call';
+import type { JoinSource } from '../reporting';
+import { CallingState } from '../store';
+import type { CallLeaveOptions } from '../types';
+
+/**
+ * Decides what a ringing call should do next, based on the current call state.
+ *
+ * The `call.accepted`, `call.rejected` and `call.missed` handlers and the ring
+ * state poller both run this. They differ only in how the state got there: the
+ * handlers rely on `CallState.updateFromEvent`, which runs before them, and the
+ * poller applies the polled ring state itself.
+ *
+ * @param call the call to reconcile.
+ * @param joinSource which of the two triggered this run, reported on the
+ * caller's join: `ring-ws` for the event handlers, `ring-poll-api` for the
+ * poller.
+ * @returns whether the ring reached a terminal state. A failed join is not
+ * terminal: the caller should keep trying while the ring is open.
+ */
+export const reconcileRingState = async (
+  call: Call,
+  joinSource: JoinSource,
+): Promise<boolean> => {
+  if (call.state.callingState !== CallingState.RINGING) return true;
+  return call.isCreatedByMe
+    ? reconcileAsCaller(call, joinSource)
+    : reconcileAsCallee(call);
+};
+
+const reconcileAsCaller = async (
+  call: Call,
+  joinSource: JoinSource,
+): Promise<boolean> => {
+  const { session, members, endedAt } = call.state;
+  const currentUserId = call.currentUserId;
+
+  // checked before `accepted_by`: an ended session cannot be joined
+  if (endedAt || session?.ended_at) {
+    call.logger.info('ring: the call has ended, leaving');
+    // `leave` reports the remote end to callingx off `reason: 'ended'`
+    return leave(call, {
+      reject: false,
+      reason: 'ended',
+      message: 'ring: call ended',
+    });
+  }
+
+  const acceptedBy = session?.accepted_by ?? {};
+  if (Object.keys(acceptedBy).some((userId) => userId !== currentUserId)) {
+    call.logger.info('ring: the call was accepted, joining');
+    try {
+      await call.join({ joinSource });
+    } catch (err) {
+      // `doJoin` restores the ringing state when a join fails, so the ring is
+      // still open. Report it unsettled and let the next poll retry.
+      call.logger.error('Failed to join an accepted call', err);
+      return false;
+    }
+    return true;
+  }
+
+  const otherMembers = members
+    .filter((member) => member.user_id !== currentUserId)
+    .map((member) => member.user_id);
+  if (otherMembers.length === 0) return false;
+
+  const rejectedBy = session?.rejected_by ?? {};
+  if (otherMembers.every((userId) => rejectedBy[userId])) {
+    call.logger.info('ring: everyone rejected, leaving');
+    return leave(call, {
+      reject: true,
+      reason: 'cancel',
+      message: 'ring: everyone rejected',
+    });
+  }
+
+  return false;
+};
+
+// the current user's own accept or reject, on this or another device, is
+// handled by `resolveOwnRingOutcome`, and `call.ended` by `watchCallEnded`.
+const reconcileAsCallee = async (call: Call): Promise<boolean> => {
+  const createdById = call.state.createdBy?.id;
+  const rejectedBy = call.state.session?.rejected_by ?? {};
+  if (createdById && rejectedBy[createdById]) {
+    call.logger.info('ring: the caller cancelled, leaving');
+    return leave(call, {
+      reason: 'ended',
+      message: 'ring: creator rejected',
+    });
+  }
+  return false;
+};
+
+// `false` when the call could not be left, so the ring stays open for a retry.
+const leave = async (
+  call: Call,
+  options: CallLeaveOptions,
+): Promise<boolean> => {
+  try {
+    await call.leave(options);
+    return true;
+  } catch (err) {
+    call.logger.error('Failed to leave a ringing call', err);
+    return false;
+  }
+};

package/src/ringing/resolveOwnRingOutcome.ts

@@ -0,0 +1,58 @@
+import { CallingState } from '../store';
+import type { CallSessionResponse } from '../gen/coordinator';
+
+export type OwnRingOutcome = {
+  /**
+   * Whether the current user accepted or rejected the ring, on this device or
+   * on another one. Either way the ring no longer needs to time out.
+   */
+  settledByMe: boolean;
+
+  /**
+   * Set when this device should stop ringing and leave, carrying the reason to
+   * report to the native call UI.
+   */
+  leaveReason?: 'answeredElsewhere' | 'rejected';
+};
+
+export type OwnRingOutcomeInput = {
+  /** The call session to read the accept and reject maps from. */
+  session: CallSessionResponse | undefined;
+  /** The connected user, or `undefined` when there is none. */
+  currentUserId: string | undefined;
+  /** The current calling state. */
+  callingState: CallingState;
+};
+
+/**
+ * Decides what a ringing call should do about the current user's own accept or
+ * reject, which may have happened on another device.
+ *
+ * Accepting on *this* device also lands in `accepted_by`, so an acceptance only
+ * means another device took the call when this one is still ringing.
+ *
+ * Only meaningful for a ringing call; the caller checks that.
+ */
+export const resolveOwnRingOutcome = ({
+  session,
+  currentUserId,
+  callingState,
+}: OwnRingOutcomeInput): OwnRingOutcome => {
+  if (!currentUserId) return { settledByMe: false };
+
+  const acceptedByMe = Boolean(session?.accepted_by[currentUserId]);
+  const rejectedByMe = Boolean(session?.rejected_by[currentUserId]);
+  if (!acceptedByMe && !rejectedByMe) return { settledByMe: false };
+
+  const answeredElsewhere =
+    acceptedByMe && callingState === CallingState.RINGING;
+
+  return {
+    settledByMe: true,
+    leaveReason: answeredElsewhere
+      ? 'answeredElsewhere'
+      : rejectedByMe
+        ? 'rejected'
+        : undefined,
+  };
+};

package/src/rtc/Publisher.ts

@@ -150,7 +150,9 @@ export class Publisher extends BasePeerConnection {
     const sendEncodings = isSvcCodec(publishOption.codec?.name)
       ? toSvcEncodings(encodings)
       : encodings;
-    const transceiver = this.pc.addTransceiver(track, {
+    // An E2EE sender must never have media before its transform is attached,
+    // including when another track or an ICE restart negotiates this PC.
+    const transceiver = this.pc.addTransceiver(this.e2ee ? track.kind : track, {
       direction: 'sendonly',
       sendEncodings,
     });
@@ -161,23 +163,75 @@ export class Publisher extends BasePeerConnection {
     this.trackIdToTrackType.set(track.id, trackType);
     this.logger.debug(`Added ${TrackType[trackType]} transceiver`);
 
-    const params = transceiver.sender.getParameters();
-    params.degradationPreference =
-      toRTCDegradationPreference(publishOption.degradationPreference) ??
-      'maintain-framerate';
-    await transceiver.sender.setParameters(params);
     if (this.e2ee) {
-      this.e2ee.encrypt(
-        transceiver.sender,
-        publishOption.codec?.name.toLowerCase(),
-        TrackType[publishOption.trackType],
-      );
-      this.logger.debug('E2EE encryptor attached to sender');
+      await this.initEncryptedSender(transceiver, track, publishOption);
+    } else {
+      await this.setDegradationPreference(transceiver.sender, publishOption);
     }
 
     await this.negotiate();
   };
 
+  /**
+   * Attaches the encryptor, applies sender parameters, then attaches the track.
+   *
+   * `encrypt` must run before the first await: Chrome short-circuits a sender
+   * whose encoded streams aren't created in the task that created it, and the
+   * track goes on last so the sender has no media until both steps succeed.
+   */
+  private initEncryptedSender = async (
+    transceiver: RTCRtpTransceiver,
+    track: MediaStreamTrack,
+    publishOption: PublishOption,
+  ) => {
+    try {
+      const { sender } = transceiver;
+      const codec = publishOption.codec?.name.toLowerCase();
+      this.e2ee!.encrypt(sender, codec, TrackType[publishOption.trackType]);
+      this.logger.debug('E2EE encryptor attached to sender');
+      await this.setDegradationPreference(sender, publishOption);
+      await sender.replaceTrack(track);
+    } catch (err) {
+      this.retireTransceiver(transceiver, track);
+      throw err;
+    }
+  };
+
+  private setDegradationPreference = async (
+    sender: RTCRtpSender,
+    publishOption: PublishOption,
+  ) => {
+    const params = sender.getParameters();
+    params.degradationPreference =
+      toRTCDegradationPreference(publishOption.degradationPreference) ??
+      'maintain-framerate';
+    await sender.setParameters(params);
+  };
+
+  /**
+   * Discards a sender whose E2EE initialization failed.
+   *
+   * A partially initialized sender may carry no transform, so publish() must
+   * not reuse it: retiring it from the cache is what keeps a later publish or
+   * ICE restart from putting cleartext on the wire. Cleanup cannot throw, so
+   * the initialization failure is what reaches the caller.
+   */
+  private retireTransceiver = (
+    transceiver: RTCRtpTransceiver,
+    track: MediaStreamTrack,
+  ) => {
+    this.transceiverCache.remove(transceiver);
+    this.trackIdToTrackType.delete(track.id);
+    // on React Native a clone shares its native source, so stopping it here
+    // would stop the track the caller passed in. dispose() releases it.
+    if (!isReactNative()) this.stopTrack(track);
+    try {
+      transceiver.stop();
+    } catch (err) {
+      this.logger.debug('Failed to stop a retired transceiver', err);
+    }
+  };
+
   /**
    * Updates the transceiver with the given track and track type.
    */

package/src/rtc/TransceiverCache.ts

@@ -21,6 +21,23 @@ export class TransceiverCache {
     this.transceiverOrder.push(bundle.transceiver);
   };
 
+  /**
+   * Retires a failed sender from the reusable cache.
+   *
+   * A transceiver that never reached an m-section also leaves the creation
+   * history: once stopped, it is left out of every later offer, so counting
+   * it would shift the `mid` index of every transceiver added after it. One
+   * that is already associated keeps its slot, since its m-section survives
+   * as a rejected one.
+   */
+  remove = (transceiver: RTCRtpTransceiver) => {
+    const index = this.cache.findIndex((b) => b.transceiver === transceiver);
+    if (index !== -1) this.cache.splice(index, 1);
+    if (transceiver.mid) return;
+    const orderIndex = this.transceiverOrder.indexOf(transceiver);
+    if (orderIndex !== -1) this.transceiverOrder.splice(orderIndex, 1);
+  };
+
   /**
    * Gets the transceiver for the given publish option.
    */

package/src/rtc/__tests__/Publisher.test.ts

@@ -26,6 +26,7 @@ import { TransceiverCache } from '../TransceiverCache';
 import { promiseWithResolvers } from '../../helpers/promise';
 import { settled } from '../../helpers/concurrency';
 import { isFirefox } from '../../helpers/browsers';
+import { isReactNative } from '../../helpers/platforms';
 
 vi.mock('../../StreamSfuClient', () => {
   console.log('MOCKING StreamSfuClient');
@@ -40,6 +41,12 @@ vi.mock('../../helpers/browsers', async (importOriginal) => {
   return { ...actual, isFirefox: vi.fn().mockReturnValue(false) };
 });
 
+vi.mock('../../helpers/platforms', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('../../helpers/platforms')>();
+  return { ...actual, isReactNative: vi.fn().mockReturnValue(false) };
+});
+
 describe('Publisher', () => {
   const sessionId = 'session-id-test';
   let publisher: Publisher;
@@ -106,6 +113,208 @@ describe('Publisher', () => {
   });
 
   describe('Publishing', () => {
+    describe('E2EE initialization failures', () => {
+      afterEach(() => {
+        vi.mocked(isReactNative).mockReturnValue(false);
+      });
+
+      const setup = async () => {
+        await publisher.dispose();
+        const e2ee = { encrypt: vi.fn(), decrypt: vi.fn() };
+        publisher = new Publisher(
+          {
+            sfuClient,
+            dispatcher,
+            state,
+            tag: 'test',
+            enableTracing: false,
+            e2ee,
+          },
+          [
+            fromPartial<PublishOption>({
+              id: 1,
+              trackType: TrackType.VIDEO,
+              codec: { name: 'vp9' },
+            }),
+          ],
+        );
+        const transceivers: RTCRtpTransceiver[] = [];
+        vi.mocked(publisher['pc'].addTransceiver).mockImplementation((kind) => {
+          expect(kind).toBe('video');
+          const transceiver = new RTCRtpTransceiver();
+          vi.mocked(transceiver.sender.replaceTrack).mockImplementation(
+            async (track) => {
+              expect(e2ee.encrypt).toHaveBeenCalledWith(
+                transceiver.sender,
+                'vp9',
+                'VIDEO',
+              );
+              Object.assign(transceiver.sender, { track });
+            },
+          );
+          transceivers.push(transceiver);
+          return transceiver;
+        });
+        const track = new MediaStreamTrack();
+        vi.mocked(track.clone).mockImplementation(() => new MediaStreamTrack());
+        const realNegotiate = publisher['negotiate'];
+        const negotiate = vi.fn<Publisher['negotiate']>().mockResolvedValue();
+        publisher['negotiate'] = negotiate;
+        return { e2ee, transceivers, track, negotiate, realNegotiate };
+      };
+
+      it.each([
+        'encrypt',
+        'getParameters',
+        'setParameters',
+        'replaceTrack',
+      ] as const)(
+        'retires the sender after %s fails and attaches encryption on retry',
+        async (failurePoint) => {
+          const { e2ee, transceivers, track, negotiate } = await setup();
+          const error = new Error('initialization failed');
+          e2ee.encrypt.mockImplementationOnce((sender: RTCRtpSender) => {
+            expect(sender.track).toBeNull();
+            if (failurePoint === 'encrypt') throw error;
+            if (failurePoint === 'getParameters') {
+              vi.mocked(sender.getParameters).mockImplementationOnce(() => {
+                throw error;
+              });
+            } else {
+              vi.mocked(sender[failurePoint]).mockRejectedValueOnce(error);
+            }
+          });
+          await expect(publisher.publish(track, TrackType.VIDEO)).rejects.toBe(
+            error,
+          );
+          const failed = transceivers[0];
+          expect(failed.sender.track).toBeNull();
+          expect(failed.stop).toHaveBeenCalledOnce();
+          expect(publisher['transceiverCache'].items()).toHaveLength(0);
+          expect(publisher['clonedTracks'].size).toBe(0);
+          expect(negotiate).not.toHaveBeenCalled();
+
+          await publisher.publish(track, TrackType.VIDEO);
+          expect(transceivers).toHaveLength(2);
+          expect(e2ee.encrypt).toHaveBeenLastCalledWith(
+            transceivers[1].sender,
+            'vp9',
+            'VIDEO',
+          );
+          expect(transceivers[1].sender.track).not.toBeNull();
+          expect(publisher['transceiverCache'].indexOf(failed)).toBe(-1);
+          expect(publisher['transceiverCache'].indexOf(transceivers[1])).toBe(
+            0,
+          );
+          expect(negotiate).toHaveBeenCalledOnce();
+        },
+      );
+
+      it('keeps the mid index of a retired sender that reached an m-section', async () => {
+        const { e2ee, transceivers, track } = await setup();
+        const error = new Error('initialization failed');
+        e2ee.encrypt.mockImplementationOnce((sender: RTCRtpSender) => {
+          Object.assign(transceivers[0], { mid: '0' });
+          vi.mocked(sender.replaceTrack).mockRejectedValueOnce(error);
+        });
+        await expect(publisher.publish(track, TrackType.VIDEO)).rejects.toBe(
+          error,
+        );
+        expect(publisher['transceiverCache'].items()).toHaveLength(0);
+        expect(publisher['transceiverCache'].indexOf(transceivers[0])).toBe(0);
+
+        await publisher.publish(track, TrackType.VIDEO);
+        expect(publisher['transceiverCache'].indexOf(transceivers[1])).toBe(1);
+      });
+
+      it('reports the initialization failure even when cleanup throws', async () => {
+        const { e2ee, transceivers, track } = await setup();
+        const error = new Error('initialization failed');
+        e2ee.encrypt.mockImplementationOnce(() => {
+          vi.mocked(transceivers[0].stop).mockImplementationOnce(() => {
+            throw new Error('peer connection is closed');
+          });
+          throw error;
+        });
+        await expect(publisher.publish(track, TrackType.VIDEO)).rejects.toBe(
+          error,
+        );
+        expect(publisher['transceiverCache'].items()).toHaveLength(0);
+        expect(publisher['clonedTracks'].size).toBe(0);
+      });
+
+      it('leaves the cloned track alone on React Native', async () => {
+        vi.mocked(isReactNative).mockReturnValue(true);
+        const { e2ee, transceivers, track } = await setup();
+        const error = new Error('initialization failed');
+        e2ee.encrypt.mockImplementationOnce(() => {
+          throw error;
+        });
+        await expect(publisher.publish(track, TrackType.VIDEO)).rejects.toBe(
+          error,
+        );
+        const [clone] = publisher['clonedTracks'];
+        expect(clone.stop).not.toHaveBeenCalled();
+        expect(transceivers[0].stop).toHaveBeenCalledOnce();
+        expect(publisher['transceiverCache'].items()).toHaveLength(0);
+      });
+
+      it('reuses an encrypted sender when only negotiation failed', async () => {
+        const { e2ee, transceivers, track, negotiate } = await setup();
+        const error = new Error('negotiation failed');
+        negotiate.mockRejectedValueOnce(error);
+        await expect(publisher.publish(track, TrackType.VIDEO)).rejects.toBe(
+          error,
+        );
+        expect(transceivers[0].sender.track).not.toBeNull();
+        expect(transceivers[0].stop).not.toHaveBeenCalled();
+        await publisher.publish(track, TrackType.VIDEO);
+        expect(transceivers).toHaveLength(1);
+        expect(e2ee.encrypt).toHaveBeenCalledOnce();
+        expect(negotiate).toHaveBeenCalledTimes(2);
+      });
+
+      it('has no media to expose if ICE restart negotiates during parameter setup', async () => {
+        const { e2ee, transceivers, track, negotiate, realNegotiate } =
+          await setup();
+        negotiate.mockImplementation(realNegotiate);
+        publisher['publishOptions'].push(
+          fromPartial<PublishOption>({
+            id: 2,
+            trackType: TrackType.VIDEO,
+            codec: { name: 'vp9' },
+          }),
+        );
+        sfuClient.setPublisher = vi
+          .fn()
+          .mockResolvedValue({ response: { sdp: 'answer-sdp' } });
+        const parameters = promiseWithResolvers<void>();
+        e2ee.encrypt
+          .mockImplementationOnce(() => {})
+          .mockImplementationOnce((sender: RTCRtpSender) => {
+            vi.mocked(sender.setParameters).mockReturnValueOnce(
+              parameters.promise,
+            );
+          });
+        const publish = publisher.publish(track, TrackType.VIDEO);
+        await vi.waitFor(() => expect(e2ee.encrypt).toHaveBeenCalledTimes(2));
+        const [published, pending] = transceivers;
+        expect(pending.sender.track).toBeNull();
+        expect(pending.sender.replaceTrack).not.toHaveBeenCalled();
+
+        await publisher.restartIce();
+        const restart = vi.mocked(sfuClient.setPublisher).mock.calls[1][0];
+        expect(restart.tracks.map((t) => t.trackId)).toEqual([
+          published.sender.track!.id,
+        ]);
+
+        parameters.resolve();
+        await publish;
+        expect(pending.sender.track).not.toBeNull();
+        expect(sfuClient.setPublisher).toHaveBeenCalledTimes(3);
+      });
+    });
+
     it('should throw when publishing ended tracks', async () => {
       const track = new MediaStreamTrack();
       // @ts-expect-error readonly field

package/src/rtc/__tests__/mocks/webrtc.mocks.ts

@@ -60,6 +60,7 @@ const RTCRtpTransceiverMock = vi.fn(function (): Partial<RTCRtpTransceiver> {
       transform: null,
     },
     setCodecPreferences: vi.fn(),
+    stop: vi.fn(),
     mid: '',
   };
 });

package/src/rtc/e2ee/E2EEManager.ts

@@ -5,7 +5,16 @@
  * attaching their own encoded transform in these two methods.
  */
 export interface E2EEManager {
-  /** `trackType` only groups perf stats, keeping a camera and screen share apart. */
+  /**
+   * Synchronously attach a transform that encrypts the sender's outgoing frames.
+   * Must support a sender without a track, and throw if attachment fails.
+   *
+   * `sender.track` is always null here: the track is attached only after this
+   * returns, so implementations must not read it. Use `codec` and `trackType`
+   * instead.
+   *
+   * `trackType` only groups perf stats, keeping a camera and screen share apart.
+   */
   encrypt(sender: RTCRtpSender, codec?: string, trackType?: string): void;
   /** `trackType` only groups perf stats, keeping a peer's audio and video apart. */
   decrypt(receiver: RTCRtpReceiver, userId: string, trackType?: string): void;

package/src/rtc/e2ee/EncryptionManager.ts

@@ -263,9 +263,9 @@ export class EncryptionManager
     }
 
     if ((this.piped ??= new WeakSet()).has(target)) return;
-    this.piped.add(target);
     // @ts-expect-error createEncodedStreams is not in the standard typedefs
     const { readable, writable } = target.createEncodedStreams();
+    this.piped.add(target);
     this.worker.postMessage(
       { type: 'cmd.setup_transform', ...options, readable, writable },
       [readable, writable],

package/src/rtc/e2ee/SPEC.md

@@ -79,7 +79,7 @@ await call.join();
 - **Removal comes in per-epoch and per-user forms, and the names must stay distinct.** `removeKey(userId, keyIndex)` retires one epoch; `removeAllKeys(userId)` revokes the participant entirely. Do not render these as overloads of one name: dropping the index argument would then silently mean "revoke everything", which is the opposite of the caller's intent and impossible to catch in review.
 - **Every key operation's outcome is tabulated in Appendix B.** Implement the edge cases (removing the latest or active epoch, a failed import, an absent index) from that table rather than from prose.
 - **Join request carries `e2ee: true`** so the backend knows the call is encrypted.
-- The internal attach points (`encrypt(sender, codec, trackType)` / `decrypt(receiver, userId, trackType)`) are called by the RTC layer, not by apps. Keeping them behind a small interface lets an integrator plug in a different scheme (e.g. SFrame).
+- The internal attach points (`encrypt(sender, codec, trackType)` / `decrypt(receiver, userId, trackType)`) are called by the RTC layer, not by apps. The publisher creates an E2EE sender without a track and attaches media only after `encrypt` returns and sender parameters succeed. `encrypt` must synchronously attach the transform or throw, and must support a sender whose `track` is null. A failed initialization retires that transceiver so retries cannot bypass attachment. Keeping these points behind a small interface lets an integrator plug in a different scheme (e.g. SFrame).
 
 ---
 

package/src/stats/__tests__/utils.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { getStreamClientId } from '../utils';
+import { SdkType } from '../../gen/video/sfu/models/models';
+
+describe('getStreamClientId', () => {
+  const sdk = (type: SdkType) => ({
+    type,
+    major: '1',
+    minor: '43',
+    patch: '1',
+  });
+
+  it('names the React SDK', () => {
+    expect(getStreamClientId(sdk(SdkType.REACT))).toBe(
+      'stream-video-react-v1.43.1',
+    );
+  });
+
+  it('names the React Native SDK', () => {
+    expect(getStreamClientId(sdk(SdkType.REACT_NATIVE))).toBe(
+      'stream-video-react-native-v1.43.1',
+    );
+  });
+
+  it('falls back to the plain JS client for every other SDK type', () => {
+    expect(getStreamClientId(sdk(SdkType.PLAIN_JAVASCRIPT))).toBe(
+      'stream-video-js-v1.43.1',
+    );
+    expect(getStreamClientId(undefined)).toBe(
+      'stream-video-js-v0.0.0-development',
+    );
+  });
+});

package/src/stats/utils.ts

@@ -51,3 +51,18 @@ export const getSdkName = (sdk: Sdk | undefined) => {
 export const getSdkVersion = (sdk: Sdk | undefined) => {
   return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
+
+/**
+ * Returns the identifier the SFU receives in the `X-Stream-Client` header,
+ * e.g. `stream-video-react-v1.43.1`. Matches the format the coordinator
+ * already gets through the client's user agent.
+ */
+export const getStreamClientId = (sdk: Sdk | undefined) => {
+  const sdkPlatforms: Partial<Record<SdkType, string>> = {
+    [SdkType.REACT]: 'react',
+    [SdkType.REACT_NATIVE]: 'react-native',
+  };
+
+  const platform = (sdk && sdkPlatforms[sdk.type]) || 'js';
+  return `stream-video-${platform}-v${getSdkVersion(sdk)}`;
+};

package/src/store/CallState.ts

@@ -37,6 +37,7 @@ import {
   CallSessionParticipantLeftEvent,
   CallSessionResponse,
   CallSettingsResponse,
+  GetCallRingStateResponse,
   ClosedCaptionEvent,
   EgressResponse,
   MemberResponse,
@@ -1352,6 +1353,30 @@ export class CallState {
     this.setCurrentValue(this.thumbnailsSubject, call.thumbnails);
   };
 
+  /**
+   * Merges a polled ring state into the current session. Only the ring fields
+   * are touched: the endpoint does not return the session roster.
+   *
+   * @internal
+   *
+   * @param ringState the ring state as returned by the coordinator.
+   */
+  updateFromRingState = (ringState: GetCallRingStateResponse) => {
+    this.setCurrentValue(this.sessionSubject, (session) => {
+      if (!session || session.id !== ringState.session_id) return session;
+      return {
+        ...session,
+        accepted_by: ringState.accepted_by,
+        rejected_by: ringState.rejected_by,
+        missed_by: ringState.missed_by,
+        ended_at: ringState.session_ended_at ?? session.ended_at,
+      };
+    });
+    if (ringState.call_ended_at) {
+      this.setEndedAt(new Date(ringState.call_ended_at));
+    }
+  };
+
   /**
    * Updates the call state with the data received from the SFU server.
    *