@stream-io/video-client 1.59.1 → 1.60.0

package/dist/index.cjs.js

@@ -5101,7 +5101,7 @@ const toIceCandidate = (iceTrickle) => {
     }
 };
 
-const version = "1.59.1";
+const version = "1.60.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -7134,6 +7134,30 @@ class CallState {
         this.setCurrentValue(this.captioningSubject, call.captioning);
         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) => {
+        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.
      *
@@ -7445,6 +7469,19 @@ const getSdkName = (sdk) => {
 const getSdkVersion = (sdk) => {
     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.
+ */
+const getStreamClientId = (sdk) => {
+    const sdkPlatforms = {
+        [SdkType.REACT]: 'react',
+        [SdkType.REACT_NATIVE]: 'react-native',
+    };
+    const platform = (sdk && sdkPlatforms[sdk.type]) || 'js';
+    return `stream-video-${platform}-v${getSdkVersion(sdk)}`;
+};
 
 /**
  * Creates a new StatsReporter instance that collects metrics about the ongoing call and reports them to the state store
@@ -10326,7 +10363,10 @@ class StreamSfuClient {
         this.rpc = createSignalClient({
             baseUrl: server.url,
             interceptors: [
-                withHeaders({ Authorization: `Bearer ${token}` }),
+                withHeaders({
+                    Authorization: `Bearer ${token}`,
+                    'X-Stream-Client': getStreamClientId(getSdkInfo()),
+                }),
                 this.tracer && withRequestTracer(this.tracer.trace),
                 this.logger.getLogLevel() === 'trace' && withRequestLogger(this.logger),
                 withTimeout(rpcRequestTimeout, this.tracer?.trace),
@@ -10663,64 +10703,370 @@ class StreamSfuClient {
 }
 
 /**
- * Event handler that watched the delivery of `call.accepted`.
- * Once the event is received, the call is joined.
- */
-const watchCallAccepted = (call) => {
-    return async function onCallAccepted(event) {
-        // We want to discard the event if it's from the current user
-        if (event.user.id === call.currentUserId)
-            return;
-        const { state } = call;
-        if (event.call.created_by.id === call.currentUserId &&
-            state.callingState === exports.CallingState.RINGING) {
-            await call.join();
+ * 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.
+ */
+const reconcileRingState = async (call, joinSource) => {
+    if (call.state.callingState !== exports.CallingState.RINGING)
+        return true;
+    return call.isCreatedByMe
+        ? reconcileAsCaller(call, joinSource)
+        : reconcileAsCallee(call);
+};
+const reconcileAsCaller = async (call, joinSource) => {
+    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) => {
+    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, options) => {
+    try {
+        await call.leave(options);
+        return true;
+    }
+    catch (err) {
+        call.logger.error('Failed to leave a ringing call', err);
+        return false;
+    }
+};
+
+// `doJoin` restores the previous calling state when a join fails, so JOINING can
+// go back to RINGING. Only a state the ring cannot return from ends the poller.
+const ringIsOver = (callingState) => callingState !== exports.CallingState.RINGING &&
+    callingState !== exports.CallingState.JOINING;
 /**
- * Event handler that watches delivery of `call.rejected` Websocket event.
- * Once the event is received, the call is left.
+ * Polls the coordinator for the outcome of a ring the current user started.
+ *
+ * `call.accepted`, `call.rejected` and `call.missed` are delivered best-effort,
+ * with no store-and-forward, so a caller that drops one is left on a ringing
+ * screen while the callee is already in the call. After a quiet period this
+ * reads the ring state until a terminal outcome or the end of the ring window.
  */
-const watchCallRejected = (call) => {
-    return async function onCallRejected(event) {
-        // We want to discard the event if it's from the current user
-        if (event.user.id === call.currentUserId)
+class RingStatePoller {
+    logger = videoLoggerSystem.getLogger('RingStatePoller');
+    call;
+    startAfterMs;
+    intervalMs;
+    sessionId;
+    deadlineAt = 0;
+    idleTimeoutId;
+    intervalId;
+    stopped = false;
+    wasPolling = false;
+    inFlight = false;
+    unsubscribe = [];
+    constructor(call, options = {}) {
+        this.call = call;
+        this.startAfterMs = options.startAfterMs ?? 15_000;
+        this.intervalMs = options.intervalMs ?? 5_000;
+    }
+    /**
+     * Starts polling. Does nothing when the call has no session yet.
+     */
+    start = () => {
+        if (this.stopped || this.sessionId)
             return;
-        const { call: eventCall } = event;
-        const { session: callSession } = eventCall;
-        if (!callSession) {
-            call.logger.warn('No call session provided. Ignoring call.rejected event.', event);
+        if (this.call.state.callingState !== exports.CallingState.RINGING)
+            return;
+        // captured once: `call.ended` clears the call's current session
+        const sessionId = this.call.state.session?.id;
+        if (!sessionId) {
+            this.logger.warn('the call has no session');
             return;
         }
-        const rejectedBy = callSession.rejected_by;
-        const { members, callingState } = call.state;
-        if (callingState !== exports.CallingState.RINGING) {
-            call.logger.info('Call is not in ringing mode (it is either accepted or rejected already). Ignoring call.rejected event.', event);
+        this.sessionId = sessionId;
+        const ring = this.call.state.settings?.ring;
+        const maxDurationMs = ring?.auto_cancel_timeout_ms || ring?.missed_call_timeout_ms || 30_000;
+        this.deadlineAt = Date.now() + maxDurationMs;
+        // an incoming event proves the socket is alive, so the quiet period starts
+        // over: in a group ring a single rejection does not settle the ring.
+        this.unsubscribe.push(this.call.on('call.accepted', () => this.armIdleWindow()), this.call.on('call.rejected', () => this.armIdleWindow()), this.call.on('call.missed', () => this.armIdleWindow()), 
+        // the ring is over, whichever way it went. Joining an accepted call
+        // never goes through `leave`, so this is the only signal for it.
+        createSubscription(this.call.state.callingState$, (callingState) => {
+            if (ringIsOver(callingState))
+                this.stop();
+        }));
+        this.armIdleWindow();
+    };
+    /**
+     * Pauses polling, keeping the captured session, the deadline and the event
+     * subscriptions. Resuming does not extend the ring window.
+     */
+    pause = () => {
+        if (this.stopped)
+            return;
+        this.wasPolling = this.intervalId !== undefined;
+        const timers = getTimers();
+        timers.clearTimeout(this.idleTimeoutId);
+        timers.clearInterval(this.intervalId);
+        this.idleTimeoutId = undefined;
+        this.intervalId = undefined;
+    };
+    /**
+     * Resumes a paused poller. Goes straight back to polling if it was already
+     * past the quiet period, so a pause does not buy the ring another one.
+     */
+    resume = () => {
+        if (this.stopped || !this.sessionId)
+            return;
+        if (this.idleTimeoutId !== undefined || this.intervalId !== undefined) {
             return;
         }
-        if (call.isCreatedByMe) {
-            const everyoneElseRejected = members
-                .filter((m) => m.user_id !== call.currentUserId)
-                .every((m) => rejectedBy[m.user_id]);
-            if (everyoneElseRejected) {
-                call.logger.info('everyone rejected, leaving the call');
-                await call.leave({
-                    reject: true,
-                    reason: 'cancel',
-                    message: 'ring: everyone rejected',
-                });
-            }
+        if (!this.wasPolling) {
+            this.armIdleWindow();
+            return;
         }
-        else {
-            if (rejectedBy[eventCall.created_by.id]) {
-                call.logger.info('call creator rejected, leaving call');
-                globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
-                await call.leave({ message: 'ring: creator rejected' });
+        this.intervalId = getTimers().setInterval(this.runTick, this.intervalMs);
+        this.runTick();
+    };
+    /**
+     * Stops polling. The poller cannot be restarted.
+     */
+    stop = () => {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        const timers = getTimers();
+        timers.clearTimeout(this.idleTimeoutId);
+        timers.clearInterval(this.intervalId);
+        this.idleTimeoutId = undefined;
+        this.intervalId = undefined;
+        this.unsubscribe.forEach((off) => off());
+        this.unsubscribe = [];
+    };
+    armIdleWindow = () => {
+        if (this.stopped)
+            return;
+        const timers = getTimers();
+        timers.clearTimeout(this.idleTimeoutId);
+        timers.clearInterval(this.intervalId);
+        this.intervalId = undefined;
+        this.idleTimeoutId = timers.setTimeout(() => {
+            this.idleTimeoutId = undefined;
+            if (this.stopped)
+                return;
+            this.intervalId = timers.setInterval(this.runTick, this.intervalMs);
+            this.runTick();
+        }, this.startAfterMs);
+    };
+    runTick = () => {
+        this.tick().catch((err) => {
+            this.logger.warn('Failed to poll the ring state', err);
+        });
+    };
+    tick = async () => {
+        if (this.stopped || this.inFlight || !this.sessionId)
+            return;
+        const { callingState } = this.call.state;
+        if (ringIsOver(callingState) || Date.now() >= this.deadlineAt) {
+            this.stop();
+            return;
+        }
+        // mid-join: nothing to reconcile until we know whether it succeeded
+        if (callingState !== exports.CallingState.RINGING)
+            return;
+        this.inFlight = true;
+        try {
+            const ringState = await this.call.getRingState(this.sessionId);
+            if (this.stopped)
+                return;
+            this.call.state.updateFromRingState(ringState);
+            if (await reconcileRingState(this.call, 'ring-poll-api'))
+                this.stop();
+        }
+        catch (err) {
+            // a missing session, or one of another call, will never resolve
+            const status = err instanceof ErrorFromResponse ? err.status : undefined;
+            if (status === 400 || status === 404) {
+                this.logger.warn('Stopped polling the ring state', err);
+                this.stop();
             }
+            else {
+                this.logger.debug('Failed to poll the ring state', err);
+            }
+        }
+        finally {
+            this.inFlight = false;
         }
     };
+}
+
+/**
+ * Drops a call that has been ringing for too long: the caller cancels after
+ * `auto_cancel_timeout_ms`, a callee after `incoming_call_timeout_ms`.
+ *
+ * Either timeout being `0` means the call rings until something else settles it.
+ */
+class RingTimeout {
+    call;
+    timeoutId;
+    deadlineAt;
+    stopped = false;
+    constructor(call) {
+        this.call = call;
+    }
+    /**
+     * Schedules an auto-drop timeout based on the call settings.
+     * Applicable only for ringing calls.
+     */
+    start = () => {
+        if (this.stopped || this.timeoutId !== undefined)
+            return;
+        // ignore if the call is not ringing
+        if (this.call.state.callingState !== exports.CallingState.RINGING)
+            return;
+        const ring = this.call.state.settings?.ring;
+        if (!ring)
+            return;
+        const isCaller = this.call.isCreatedByMe;
+        const timeoutMs = isCaller
+            ? ring.auto_cancel_timeout_ms
+            : ring.incoming_call_timeout_ms;
+        // 0 means no auto-drop
+        if (timeoutMs <= 0)
+            return;
+        const now = Date.now();
+        this.deadlineAt ??= now + timeoutMs;
+        const delayMs = Math.max(0, this.deadlineAt - now);
+        const timers = getTimers();
+        this.timeoutId = timers.setTimeout(() => {
+            this.timeoutId = undefined;
+            // A failed timeout-triggered leave can arm a fresh retry window.
+            this.deadlineAt = undefined;
+            if (this.stopped)
+                return;
+            // the call might have stopped ringing by this point, e.g. it was already
+            // accepted and joined
+            if (this.call.state.callingState !== exports.CallingState.RINGING)
+                return;
+            this.call
+                .leave({
+                reject: true,
+                reason: 'timeout',
+                message: `ringing timeout - ${isCaller
+                    ? 'no one accepted'
+                    : `user didn't interact with incoming call screen`}`,
+            })
+                .catch((err) => {
+                videoLoggerSystem
+                    .getLogger('RingTimeout')
+                    .error('Failed to drop the call', err);
+            });
+        }, delayMs);
+    };
+    /**
+     * Pauses the timeout while preserving its original deadline.
+     */
+    pause = () => {
+        if (this.stopped || this.timeoutId === undefined)
+            return;
+        getTimers().clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+    };
+    /**
+     * Cancels a scheduled auto-drop timeout. It cannot be armed again.
+     */
+    stop = () => {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        getTimers().clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        this.deadlineAt = undefined;
+    };
+}
+
+/**
+ * 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.
+ */
+const resolveOwnRingOutcome = ({ session, currentUserId, callingState, }) => {
+    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 === exports.CallingState.RINGING;
+    return {
+        settledByMe: true,
+        leaveReason: answeredElsewhere
+            ? 'answeredElsewhere'
+            : rejectedByMe
+                ? 'rejected'
+                : undefined,
+    };
 };
+
 /**
  * Event handler that watches the delivery of `call.ended` Websocket event.
  */
@@ -11121,14 +11467,18 @@ const registerEventHandlers = (call, dispatcher) => {
  * @param call the call to register event handlers for.
  */
 const registerRingingCallEventHandlers = (call) => {
-    const coordinatorRingEvents = {
-        'call.accepted': watchCallAccepted(call),
-        'call.rejected': watchCallRejected(call),
+    const reconcile = () => {
+        reconcileRingState(call, 'ring-ws').catch((err) => {
+            call.logger.error('Failed to reconcile the ring state', err);
+        });
     };
-    const eventHandlers = Object.keys(coordinatorRingEvents).map((event) => {
-        const eventName = event;
-        return call.on(eventName, coordinatorRingEvents[eventName]);
-    });
+    // each event needs its own closure. `call.missed` is deliberately absent:
+    // nothing in the reconciler acts on `missed_by`, so the auto-drop owns the
+    // "nobody answered" case until the server-owned ring timeout lands.
+    const eventHandlers = [
+        call.on('call.accepted', () => reconcile()),
+        call.on('call.rejected', () => reconcile()),
+    ];
     return () => {
         eventHandlers.forEach((unsubscribe) => unsubscribe());
     };
@@ -15176,7 +15526,8 @@ class Call {
     statsReporter;
     sfuStatsReporter;
     lastStatsOptions;
-    dropTimeout;
+    ringTimeout;
+    ringStatePoller;
     clientStore;
     streamClient;
     clientEventReporter;
@@ -15354,22 +15705,19 @@ class Call {
         createSubscription(this.state.session$, (session) => {
             if (!this.ringing)
                 return;
-            const receiverId = this.clientStore.connectedUser?.id;
-            if (!receiverId)
-                return;
-            const isAcceptedByMe = Boolean(session?.accepted_by[receiverId]);
-            const isRejectedByMe = Boolean(session?.rejected_by[receiverId]);
-            if (isAcceptedByMe || isRejectedByMe) {
+            const { settledByMe, leaveReason } = resolveOwnRingOutcome({
+                session,
+                currentUserId: this.currentUserId,
+                callingState: this.state.callingState,
+            });
+            if (settledByMe)
                 this.cancelAutoDrop();
-            }
-            const isAcceptedElsewhere = isAcceptedByMe && this.state.callingState === exports.CallingState.RINGING;
-            if ((isAcceptedElsewhere || isRejectedByMe) &&
-                !hasPending(this.joinLeaveConcurrencyTag)) {
-                globalThis.streamRNVideoSDK?.callingX?.endCall(this, isAcceptedElsewhere ? 'answeredElsewhere' : 'rejected');
-                this.leave().catch(() => {
-                    this.logger.error('Could not leave a call that was accepted or rejected elsewhere');
-                });
-            }
+            if (!leaveReason || hasPending(this.joinLeaveConcurrencyTag))
+                return;
+            globalThis.streamRNVideoSDK?.callingX?.endCall(this, leaveReason);
+            this.leave().catch(() => {
+                this.logger.error('Could not leave a call that was accepted or rejected elsewhere');
+            });
         }));
     };
     handleRingingCall = () => {
@@ -15415,6 +15763,7 @@ class Call {
                 this.state.setCallingState(exports.CallingState.RINGING);
             }
             this.scheduleAutoDrop();
+            this.scheduleRingStatePolling();
             this.leaveCallHooks.add(registerRingingCallEventHandlers(this));
         }
     };
@@ -15501,6 +15850,12 @@ class Call {
         if (this.state.callingState === exports.CallingState.LEFT) {
             throw new Error('Cannot leave call that has already been left.');
         }
+        // before the first await: the calling state stays RINGING well into the
+        // teardown, so pause both watchdogs before they can race this leave. They
+        // keep their deadlines, so a failed leave resumes them without handing the
+        // ring another window.
+        this.ringTimeout?.pause();
+        this.ringStatePoller?.pause();
         await withoutConcurrency(this.joinLeaveConcurrencyTag, async () => {
             const callingState = this.state.callingState;
             if (callingState === exports.CallingState.LEFT) {
@@ -15590,6 +15945,7 @@ class Call {
             this.unifiedSessionId = undefined;
             this.ringingSubject.next(false);
             this.cancelAutoDrop();
+            this.cancelRingStatePolling();
             this.clientStore.unregisterCall(this);
             globalThis.streamRNVideoSDK?.callManager.stop({
                 isRingingTypeCall: this.ringing,
@@ -15628,6 +15984,15 @@ class Call {
                     this.logger.warn('Failed to dispose media engine', err);
                 });
             }
+        }).catch((err) => {
+            if (!hasPending(this.joinLeaveConcurrencyTag) &&
+                this.state.callingState === exports.CallingState.RINGING) {
+                // resume, never re-arm: a fresh watchdog would restart the ring
+                // window this leave was already most of the way through
+                this.ringTimeout?.start();
+                this.ringStatePoller?.resume();
+            }
+            throw err;
         });
     };
     /**
@@ -15778,6 +16143,21 @@ class Call {
     ring = async (data = {}) => {
         return this.streamClient.post(`${this.streamClientBasePath}/ring`, data);
     };
+    /**
+     * Returns who accepted, rejected or missed the ring for a call session.
+     * Safe to poll: it performs no writes and emits no events.
+     *
+     * @param callSessionId the call session to read. Defaults to the current one.
+     * Pass it explicitly to read a session that has already ended, as ending a
+     * call clears its current session.
+     */
+    getRingState = async (callSessionId) => {
+        const sessionId = callSessionId ?? this.state.session?.id;
+        if (!sessionId) {
+            throw new Error('Cannot read the ring state: the call has no session');
+        }
+        return this.streamClient.get(`${this.streamClientBasePath}/ring_state`, { call_session_id: sessionId });
+    };
     /**
      * A shortcut for {@link Call.get} with `notify` parameter set to `true`.
      * Will send a `call.notification` event to the call members.
@@ -15818,7 +16198,7 @@ class Call {
      *
      * @returns a promise which resolves once the call join-flow has finished.
      */
-    join = singleFlight(async ({ maxJoinRetries = 3, joinResponseTimeout, rpcRequestTimeout, allowOwnTracksLoopback = false, ...data } = {}) => {
+    join = singleFlight(async ({ maxJoinRetries = 3, joinResponseTimeout, rpcRequestTimeout, allowOwnTracksLoopback = false, joinSource, ...data } = {}) => {
         const callingState = this.state.callingState;
         if ([exports.CallingState.JOINED, exports.CallingState.JOINING].includes(callingState)) {
             throw new Error(`Illegal State: call.join() shall be called only once`);
@@ -15850,7 +16230,7 @@ class Call {
         const joinData = data;
         maxJoinRetries = Math.max(maxJoinRetries, 1);
         try {
-            await this.clientEventReporter.withJoinLifecycle(this.cid, 'first-attempt', async () => {
+            await this.clientEventReporter.withJoinLifecycle(this.cid, { joinReason: 'first-attempt', joinSource }, async () => {
                 for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
                     try {
                         this.logger.trace(`Joining call (${attempt})`, this.cid);
@@ -16576,7 +16956,7 @@ class Call {
         const joinReason = this.reconnectReason === ReconnectReason.NETWORK_BACK_ONLINE
             ? 'network-available'
             : 'full-rejoin';
-        await this.clientEventReporter.withJoinLifecycle(this.cid, joinReason, () => this.doJoin(this.joinCallData));
+        await this.clientEventReporter.withJoinLifecycle(this.cid, { joinReason }, () => this.doJoin(this.joinCallData));
         await this.restorePublishedTracks();
         this.restoreSubscribedTracks();
         this.sfuStatsReporter?.sendReconnectionTime(WebsocketReconnectStrategy.REJOIN, (Date.now() - reconnectStartTime) / 1000);
@@ -16600,7 +16980,7 @@ class Call {
         const migrationTask = makeSafePromise(currentSfuClient.enterMigration());
         try {
             const currentSfu = currentSfuClient.edgeName;
-            await this.clientEventReporter.withJoinLifecycle(this.cid, 'migration', () => this.doJoin({
+            await this.clientEventReporter.withJoinLifecycle(this.cid, { joinReason: 'migration' }, () => this.doJoin({
                 ...this.joinCallData,
                 migrating_from: currentSfu,
                 migrating_from_list: [currentSfu],
@@ -17373,40 +17753,36 @@ class Call {
      */
     scheduleAutoDrop = () => {
         this.cancelAutoDrop();
-        const settings = this.state.settings;
-        if (!settings)
-            return;
-        // ignore if the call is not ringing
-        if (this.state.callingState !== exports.CallingState.RINGING)
-            return;
-        const timeoutInMs = this.isCreatedByMe
-            ? settings.ring.auto_cancel_timeout_ms
-            : settings.ring.incoming_call_timeout_ms;
-        // 0 means no auto-drop
-        if (timeoutInMs <= 0)
-            return;
-        this.dropTimeout = setTimeout(() => {
-            // the call might have stopped ringing by this point,
-            // e.g. it was already accepted and joined
-            if (this.state.callingState !== exports.CallingState.RINGING)
-                return;
-            this.leave({
-                reject: true,
-                reason: 'timeout',
-                message: `ringing timeout - ${this.isCreatedByMe
-                    ? 'no one accepted'
-                    : `user didn't interact with incoming call screen`}`,
-            }).catch((err) => {
-                this.logger.error('Failed to drop call', err);
-            });
-        }, timeoutInMs);
+        this.ringTimeout = new RingTimeout(this);
+        this.ringTimeout.start();
     };
     /**
      * Cancels a scheduled auto-drop timeout.
      */
     cancelAutoDrop = () => {
-        clearTimeout(this.dropTimeout);
-        this.dropTimeout = undefined;
+        this.ringTimeout?.stop();
+        this.ringTimeout = undefined;
+    };
+    /**
+     * Starts polling for the ring outcome. Applicable only to ringing calls the
+     * current user created.
+     */
+    scheduleRingStatePolling = () => {
+        this.cancelRingStatePolling();
+        if (!this.isCreatedByMe)
+            return;
+        const options = this.streamClient.options.ringStatePolling;
+        if (options === false)
+            return;
+        this.ringStatePoller = new RingStatePoller(this, options);
+        this.ringStatePoller.start();
+    };
+    /**
+     * Cancels the ring state polling.
+     */
+    cancelRingStatePolling = () => {
+        this.ringStatePoller?.stop();
+        this.ringStatePoller = undefined;
     };
     /**
      * Retrieves the list of recordings for the current call or call session.
@@ -19077,11 +19453,11 @@ class StreamClient {
         return await this.wsConnection.connect(this.defaultWSTimeout);
     };
     getSdkVersion = () => this.options.clientAppIdentifier?.sdkVersion ||
-        "1.59.1";
+        "1.60.0";
     getUserAgent = () => {
         if (!this.cachedUserAgent) {
             const { clientAppIdentifier = {} } = this.options;
-            const { sdkName = 'js', sdkVersion = "1.59.1", ...extras } = clientAppIdentifier;
+            const { sdkName = 'js', sdkVersion = "1.60.0", ...extras } = clientAppIdentifier;
             this.cachedUserAgent = [
                 `stream-video-${sdkName}-v${sdkVersion}`,
                 ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -19214,6 +19590,7 @@ class ClientEventReporter {
     callContexts = new Map();
     joinAttemptIds = new Map();
     joinReasons = new Map();
+    joinSources = new Map();
     coordinatorPairs = new Map();
     wsPairs = new Map();
     peerConnectionPairs = new Map();
@@ -19328,6 +19705,7 @@ class ClientEventReporter {
         this.callContexts.delete(cid);
         this.joinAttemptIds.delete(cid);
         this.joinReasons.delete(cid);
+        this.joinSources.delete(cid);
         this.coordinatorPairs.delete(cid);
         this.wsPairs.delete(cid);
         this.firstFrameReported.delete(`${cid}:FirstVideoFrame`);
@@ -19352,7 +19730,12 @@ class ClientEventReporter {
             this.logger.warn('Failed to start join correlation', err);
         }
     };
-    withJoinLifecycle = async (cid, joinReason, op) => {
+    withJoinLifecycle = async (cid, options, op) => {
+        const { joinReason, joinSource } = options;
+        if (joinSource)
+            this.joinSources.set(cid, joinSource);
+        else
+            this.joinSources.delete(cid);
         this.startCorrelation(cid, joinReason);
         try {
             return await op();
@@ -19361,6 +19744,9 @@ class ClientEventReporter {
             this.closeCallPairs(cid);
             throw err;
         }
+        finally {
+            this.joinSources.delete(cid);
+        }
     };
     track = async (cid, stage, op) => {
         this.beginAttempt(cid, stage);
@@ -19484,6 +19870,7 @@ class ClientEventReporter {
                 startedAt: Date.now(),
                 joinAttemptIdSnapshot: this.joinAttemptIds.get(cid),
                 joinReasonSnapshot: this.joinReasons.get(cid),
+                joinSourceSnapshot: this.joinSources.get(cid),
             };
             this.coordinatorPairs.set(cid, pair);
             this.sendForCall(cid, {
@@ -19491,6 +19878,7 @@ class ClientEventReporter {
                 ...(pair.joinReasonSnapshot && {
                     join_reason: pair.joinReasonSnapshot,
                 }),
+                ...(pair.joinSourceSnapshot && { source: pair.joinSourceSnapshot }),
                 event_type: 'initiated',
             });
         }
@@ -19505,6 +19893,7 @@ class ClientEventReporter {
             ...this.buildCommon(cid, 'CoordinatorJoin', pair),
             ...this.sessionIdField(cid),
             ...(pair.joinReasonSnapshot && { join_reason: pair.joinReasonSnapshot }),
+            ...(pair.joinSourceSnapshot && { source: pair.joinSourceSnapshot }),
             event_type: 'completed',
             outcome: 'success',
             retry_count_attempt: pair.attempts - 1,
@@ -19523,6 +19912,7 @@ class ClientEventReporter {
             ...this.buildCommon(cid, 'CoordinatorJoin', pair),
             ...this.sessionIdField(cid),
             ...(pair.joinReasonSnapshot && { join_reason: pair.joinReasonSnapshot }),
+            ...(pair.joinSourceSnapshot && { source: pair.joinSourceSnapshot }),
             event_type: 'completed',
             outcome: 'failure',
             retry_count_attempt: pair.attempts - 1,