@stream-io/video-client 0.1.3 → 0.1.5

package/dist/src/Call.d.ts

@@ -164,7 +164,6 @@ export declare class Call {
      */
     join: (data?: JoinCallData) => Promise<void>;
     private waitForJoinResponse;
-    private assertCallJoined;
     /**
      * Starts publishing the given video stream to the call.
      * The stream will be stopped if the user changes an input device, or if the user leaves the call.
@@ -276,6 +275,7 @@ export declare class Call {
      * @returns
      */
     updatePublishQuality: (enabledRids: string[]) => Promise<void | undefined>;
+    private assertCallJoined;
     /**
      * Sends a reaction to the other call participants.
      *

package/dist/src/StreamSfuClient.d.ts

@@ -2,7 +2,7 @@ import type { WebSocket } from 'ws';
 import type { FinishedUnaryCall } from '@protobuf-ts/runtime-rpc';
 import { Dispatcher, IceTrickleBuffer } from './rtc';
 import { JoinRequest, SfuRequest } from './gen/video/sfu/event/events';
-import { SendAnswerRequest, SetPublisherRequest, TrackSubscriptionDetails, UpdateMuteStatesRequest } from './gen/video/sfu/signal_rpc/signal';
+import { ICERestartRequest, SendAnswerRequest, SetPublisherRequest, TrackSubscriptionDetails, UpdateMuteStatesRequest } from './gen/video/sfu/signal_rpc/signal';
 import { ICETrickle, TrackType } from './gen/video/sfu/models/models';
 import { SFUResponse } from './gen/coordinator';
 export type StreamSfuClientConstructor = {
@@ -84,6 +84,7 @@ export declare class StreamSfuClient {
     setPublisher: (data: Omit<SetPublisherRequest, 'sessionId'>) => Promise<FinishedUnaryCall<SetPublisherRequest, import("./gen/video/sfu/signal_rpc/signal").SetPublisherResponse>>;
     sendAnswer: (data: Omit<SendAnswerRequest, 'sessionId'>) => Promise<FinishedUnaryCall<SendAnswerRequest, import("./gen/video/sfu/signal_rpc/signal").SendAnswerResponse>>;
     iceTrickle: (data: Omit<ICETrickle, 'sessionId'>) => Promise<FinishedUnaryCall<ICETrickle, import("./gen/video/sfu/signal_rpc/signal").ICETrickleResponse>>;
+    iceRestart: (data: Omit<ICERestartRequest, 'sessionId'>) => Promise<FinishedUnaryCall<ICERestartRequest, import("./gen/video/sfu/signal_rpc/signal").ICERestartResponse>>;
     updateMuteState: (trackType: TrackType, muted: boolean) => Promise<FinishedUnaryCall<UpdateMuteStatesRequest, import("./gen/video/sfu/signal_rpc/signal").UpdateMuteStatesResponse>>;
     updateMuteStates: (data: Omit<UpdateMuteStatesRequest, 'sessionId'>) => Promise<FinishedUnaryCall<UpdateMuteStatesRequest, import("./gen/video/sfu/signal_rpc/signal").UpdateMuteStatesResponse>>;
     join: (data: Omit<JoinRequest, 'sessionId' | 'token'>) => Promise<void>;

package/dist/src/StreamVideoClient.d.ts

@@ -2,7 +2,7 @@ import { Call } from './Call';
 import { StreamClient } from './coordinator/connection/client';
 import { StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore } from './store';
 import type { ConnectedEvent, CreateDeviceRequest, CreateGuestRequest, CreateGuestResponse, GetEdgesResponse, ListDevicesResponse, QueryCallsRequest } from './gen/coordinator';
-import type { EventHandler, EventTypes, Logger, StreamClientOptions, TokenOrProvider, TokenProvider, User, UserWithId } from './coordinator/connection/types';
+import type { EventHandler, EventTypes, Logger, LogLevel, StreamClientOptions, TokenOrProvider, TokenProvider, User, UserWithId } from './coordinator/connection/types';
 /**
  * A `StreamVideoClient` instance lets you communicate with our API, and authenticate users.
  */
@@ -11,8 +11,7 @@ export declare class StreamVideoClient {
      * A reactive store that exposes all the state variables in a reactive manner - you can subscribe to changes of the different state variables. Our library is built in a way that all state changes are exposed in this store, so all UI changes in your application should be handled by subscribing to these variables.
      */
     readonly readOnlyStateStore: StreamVideoReadOnlyStateStore;
-    readonly user?: User;
-    readonly token?: TokenOrProvider;
+    readonly logLevel: LogLevel;
     readonly logger: Logger;
     protected readonly writeableStateStore: StreamVideoWriteableStateStore;
     streamClient: StreamClient;
@@ -38,7 +37,7 @@ export declare class StreamVideoClient {
      * @param user the user to connect.
      * @param token a token or a function that returns a token.
      */
-    connectUser(user?: User, token?: TokenOrProvider): Promise<void | ConnectedEvent>;
+    connectUser(user: User, token?: TokenOrProvider): Promise<void | ConnectedEvent>;
     /**
      * Disconnects the currently connected user from the client.
      *

package/dist/src/coordinator/connection/client.d.ts

@@ -39,8 +39,6 @@ export declare class StreamClient {
     rejectConnectionId?: Function;
     connectionIdPromise?: Promise<string | undefined>;
     private nextRequestAbortController;
-    private waitForConnectPromise?;
-    private resolveConnectPromise?;
     /**
      * Initialize a client.
      *
@@ -60,10 +58,6 @@ export declare class StreamClient {
     getLocationHint: (hintUrl?: string, timeout?: number) => Promise<string>;
     _getConnectionID: () => string | undefined;
     _hasConnectionID: () => boolean;
-    /**
-     * This will start a promise to hold API calls until `connectUser` is called, useful when user is set in `StreamVideoClient constructor`
-     */
-    startWaitingForConnection: () => void;
     /**
      * connectUser - Set the current user and open a WebSocket connection
      *

package/dist/src/gen/video/sfu/event/events.d.ts

@@ -160,6 +160,14 @@ export interface SfuEvent {
          * @generated from protobuf field: stream.video.sfu.event.GoAway go_away = 20;
          */
         goAway: GoAway;
+    } | {
+        oneofKind: 'iceRestart';
+        /**
+         * ICERestart tells the client to perform ICE restart.
+         *
+         * @generated from protobuf field: stream.video.sfu.event.ICERestart ice_restart = 21;
+         */
+        iceRestart: ICERestart;
     } | {
         oneofKind: undefined;
     };
@@ -186,6 +194,15 @@ export interface ICETrickle {
      */
     iceCandidate: string;
 }
+/**
+ * @generated from protobuf message stream.video.sfu.event.ICERestart
+ */
+export interface ICERestart {
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.PeerType peer_type = 1;
+     */
+    peerType: PeerType;
+}
 /**
  * SfuRequest is a message that is sent from the client to the SFU.
  *
@@ -312,6 +329,20 @@ export interface JoinRequest {
      * @generated from protobuf field: stream.video.sfu.event.Migration migration = 5;
      */
     migration?: Migration;
+    /**
+     * Fast reconnect flag explicitly indicates that if the participant session
+     * and the associated state is still present in the SFU, the client is ready
+     * to restore the PeerConnection with an ICE restart. If the SFU replies with
+     * "reconnected: true" in its JoinResponse, then it is safe to perform an ICE
+     * restart or else the existing PeerConnections must be cleaned up.
+     *
+     * For the SFU, fast_reconnect:false indicates that even if it has the state
+     * cached, the client state is not in sync and hence it must be cleaned up before
+     * proceeding further.
+     *
+     * @generated from protobuf field: bool fast_reconnect = 6;
+     */
+    fastReconnect: boolean;
 }
 /**
  * @generated from protobuf message stream.video.sfu.event.Migration
@@ -335,11 +366,13 @@ export interface Migration {
  */
 export interface JoinResponse {
     /**
-     * TODO: include full list of participants with track and audio info
-     *
      * @generated from protobuf field: stream.video.sfu.models.CallState call_state = 1;
      */
     callState?: CallState;
+    /**
+     * @generated from protobuf field: bool reconnected = 2;
+     */
+    reconnected: boolean;
 }
 /**
  * ParticipantJoined is fired when a user joins a call
@@ -666,6 +699,16 @@ declare class ICETrickle$Type extends MessageType<ICETrickle> {
  * @generated MessageType for protobuf message stream.video.sfu.event.ICETrickle
  */
 export declare const ICETrickle: ICETrickle$Type;
+declare class ICERestart$Type extends MessageType<ICERestart> {
+    constructor();
+    create(value?: PartialMessage<ICERestart>): ICERestart;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ICERestart): ICERestart;
+    internalBinaryWrite(message: ICERestart, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.event.ICERestart
+ */
+export declare const ICERestart: ICERestart$Type;
 declare class SfuRequest$Type extends MessageType<SfuRequest> {
     constructor();
     create(value?: PartialMessage<SfuRequest>): SfuRequest;

package/dist/src/gen/video/sfu/models/models.d.ts

@@ -534,6 +534,18 @@ export declare enum ErrorCode {
      * @generated from protobuf enum value: ERROR_CODE_PARTICIPANT_MIGRATION_FAILED = 202;
      */
     PARTICIPANT_MIGRATION_FAILED = 202,
+    /**
+     * @generated from protobuf enum value: ERROR_CODE_PARTICIPANT_MIGRATING = 203;
+     */
+    PARTICIPANT_MIGRATING = 203,
+    /**
+     * @generated from protobuf enum value: ERROR_CODE_PARTICIPANT_RECONNECT_FAILED = 204;
+     */
+    PARTICIPANT_RECONNECT_FAILED = 204,
+    /**
+     * @generated from protobuf enum value: ERROR_CODE_PARTICIPANT_MEDIA_TRANSPORT_FAILURE = 205;
+     */
+    PARTICIPANT_MEDIA_TRANSPORT_FAILURE = 205,
     /**
      * @generated from protobuf enum value: ERROR_CODE_CALL_NOT_FOUND = 300;
      */

package/dist/src/gen/video/sfu/signal_rpc/signal.client.d.ts

@@ -1,5 +1,5 @@
 import type { RpcOptions, RpcTransport, ServiceInfo, UnaryCall } from '@protobuf-ts/runtime-rpc';
-import type { ICETrickleResponse, SendAnswerRequest, SendAnswerResponse, SetPublisherRequest, SetPublisherResponse, UpdateMuteStatesRequest, UpdateMuteStatesResponse, UpdateSubscriptionsRequest, UpdateSubscriptionsResponse } from './signal';
+import type { ICERestartRequest, ICERestartResponse, ICETrickleResponse, SendAnswerRequest, SendAnswerResponse, SetPublisherRequest, SetPublisherResponse, UpdateMuteStatesRequest, UpdateMuteStatesResponse, UpdateSubscriptionsRequest, UpdateSubscriptionsResponse } from './signal';
 import type { ICETrickle } from '../models/models';
 /**
  * @generated from protobuf service stream.video.sfu.signal.SignalServer
@@ -34,6 +34,10 @@ export interface ISignalServerClient {
      * @generated from protobuf rpc: UpdateMuteStates(stream.video.sfu.signal.UpdateMuteStatesRequest) returns (stream.video.sfu.signal.UpdateMuteStatesResponse);
      */
     updateMuteStates(input: UpdateMuteStatesRequest, options?: RpcOptions): UnaryCall<UpdateMuteStatesRequest, UpdateMuteStatesResponse>;
+    /**
+     * @generated from protobuf rpc: IceRestart(stream.video.sfu.signal.ICERestartRequest) returns (stream.video.sfu.signal.ICERestartResponse);
+     */
+    iceRestart(input: ICERestartRequest, options?: RpcOptions): UnaryCall<ICERestartRequest, ICERestartResponse>;
 }
 /**
  * @generated from protobuf service stream.video.sfu.signal.SignalServer
@@ -75,4 +79,8 @@ export declare class SignalServerClient implements ISignalServerClient, ServiceI
      * @generated from protobuf rpc: UpdateMuteStates(stream.video.sfu.signal.UpdateMuteStatesRequest) returns (stream.video.sfu.signal.UpdateMuteStatesResponse);
      */
     updateMuteStates(input: UpdateMuteStatesRequest, options?: RpcOptions): UnaryCall<UpdateMuteStatesRequest, UpdateMuteStatesResponse>;
+    /**
+     * @generated from protobuf rpc: IceRestart(stream.video.sfu.signal.ICERestartRequest) returns (stream.video.sfu.signal.ICERestartResponse);
+     */
+    iceRestart(input: ICERestartRequest, options?: RpcOptions): UnaryCall<ICERestartRequest, ICERestartResponse>;
 }

package/dist/src/gen/video/sfu/signal_rpc/signal.d.ts

@@ -2,6 +2,28 @@ import { Error, PeerType, TrackInfo, TrackType, VideoDimension } from '../models
 import { ServiceType } from '@protobuf-ts/runtime-rpc';
 import type { BinaryReadOptions, BinaryWriteOptions, IBinaryReader, IBinaryWriter, PartialMessage } from '@protobuf-ts/runtime';
 import { MessageType } from '@protobuf-ts/runtime';
+/**
+ * @generated from protobuf message stream.video.sfu.signal.ICERestartRequest
+ */
+export interface ICERestartRequest {
+    /**
+     * @generated from protobuf field: string session_id = 1;
+     */
+    sessionId: string;
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.PeerType peer_type = 2;
+     */
+    peerType: PeerType;
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.ICERestartResponse
+ */
+export interface ICERestartResponse {
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.Error error = 1;
+     */
+    error?: Error;
+}
 /**
  * @generated from protobuf message stream.video.sfu.signal.UpdateMuteStatesRequest
  */
@@ -175,6 +197,26 @@ export interface SetPublisherResponse {
      */
     error?: Error;
 }
+declare class ICERestartRequest$Type extends MessageType<ICERestartRequest> {
+    constructor();
+    create(value?: PartialMessage<ICERestartRequest>): ICERestartRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ICERestartRequest): ICERestartRequest;
+    internalBinaryWrite(message: ICERestartRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.ICERestartRequest
+ */
+export declare const ICERestartRequest: ICERestartRequest$Type;
+declare class ICERestartResponse$Type extends MessageType<ICERestartResponse> {
+    constructor();
+    create(value?: PartialMessage<ICERestartResponse>): ICERestartResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ICERestartResponse): ICERestartResponse;
+    internalBinaryWrite(message: ICERestartResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.ICERestartResponse
+ */
+export declare const ICERestartResponse: ICERestartResponse$Type;
 declare class UpdateMuteStatesRequest$Type extends MessageType<UpdateMuteStatesRequest> {
     constructor();
     create(value?: PartialMessage<UpdateMuteStatesRequest>): UpdateMuteStatesRequest;

package/dist/src/rtc/Publisher.d.ts

@@ -2,13 +2,16 @@ import { StreamSfuClient } from '../StreamSfuClient';
 import { TrackInfo, TrackType } from '../gen/video/sfu/models/models';
 import { CallState } from '../store';
 import { PublishOptions } from '../types';
+import { Dispatcher } from './Dispatcher';
 export type PublisherOpts = {
     sfuClient: StreamSfuClient;
     state: CallState;
+    dispatcher: Dispatcher;
     connectionConfig?: RTCConfiguration;
     isDtxEnabled: boolean;
     isRedEnabled: boolean;
     preferredVideoCodec?: string;
+    iceRestartDelay?: number;
 };
 /**
  * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
@@ -17,6 +20,7 @@ export type PublisherOpts = {
 export declare class Publisher {
     private pc;
     private readonly state;
+    private readonly dispatcher;
     private readonly transceiverRegistry;
     /**
      * An array maintaining the order how transceivers were added to the peer connection.
@@ -31,7 +35,9 @@ export declare class Publisher {
     private readonly isDtxEnabled;
     private readonly isRedEnabled;
     private readonly preferredVideoCodec?;
-    private logger;
+    private readonly unsubscribeOnIceRestart;
+    private readonly iceRestartDelay;
+    private isIceRestarting;
     /**
      * The SFU client instance to use for publishing and signaling.
      */
@@ -42,11 +48,13 @@ export declare class Publisher {
      * @param connectionConfig the connection configuration to use.
      * @param sfuClient the SFU client to use.
      * @param state the call state to use.
+     * @param dispatcher the dispatcher to use.
      * @param isDtxEnabled whether DTX is enabled.
      * @param isRedEnabled whether RED is enabled.
      * @param preferredVideoCodec the preferred video codec.
+     * @param iceRestartDelay the delay in milliseconds to wait before restarting ICE once connection goes to `disconnected` state.
      */
-    constructor({ connectionConfig, sfuClient, state, isDtxEnabled, isRedEnabled, preferredVideoCodec, }: PublisherOpts);
+    constructor({ connectionConfig, sfuClient, dispatcher, state, isDtxEnabled, isRedEnabled, preferredVideoCodec, iceRestartDelay, }: PublisherOpts);
     private createPeerConnection;
     /**
      * Closes the publisher PeerConnection and cleans up the resources.

package/dist/src/rtc/Subscriber.d.ts

@@ -6,6 +6,7 @@ export type SubscriberOpts = {
     dispatcher: Dispatcher;
     state: CallState;
     connectionConfig?: RTCConfiguration;
+    iceRestartDelay?: number;
 };
 /**
  * A wrapper around the `RTCPeerConnection` that handles the incoming
@@ -13,10 +14,13 @@ export type SubscriberOpts = {
  */
 export declare class Subscriber {
     private pc;
-    private readonly unregisterOnSubscriberOffer;
     private sfuClient;
     private dispatcher;
     private state;
+    private readonly unregisterOnSubscriberOffer;
+    private readonly unregisterOnIceRestart;
+    private readonly iceRestartDelay;
+    private isIceRestarting;
     /**
      * Constructs a new `Subscriber` instance.
      *
@@ -24,8 +28,9 @@ export declare class Subscriber {
      * @param dispatcher the dispatcher to use.
      * @param state the state of the call.
      * @param connectionConfig the connection configuration to use.
+     * @param iceRestartDelay the delay in milliseconds to wait before restarting ICE when connection goes to `disconnected` state.
      */
-    constructor({ sfuClient, dispatcher, state, connectionConfig, }: SubscriberOpts);
+    constructor({ sfuClient, dispatcher, state, connectionConfig, iceRestartDelay, }: SubscriberOpts);
     /**
      * Creates a new `RTCPeerConnection` instance with the given configuration.
      *
@@ -52,7 +57,7 @@ export declare class Subscriber {
     /**
      * Restarts the ICE connection and renegotiates with the SFU.
      */
-    restartIce: () => void;
+    restartIce: () => Promise<void>;
     private handleOnTrack;
     private onIceCandidate;
     private negotiate;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.1.3";
+export declare const version = "0.1.5";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "packageManager": "yarn@3.2.4",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",

package/src/Call.ts

@@ -72,6 +72,7 @@ import {
 import {
   BehaviorSubject,
   debounce,
+  filter,
   map,
   pairwise,
   Subject,
@@ -371,12 +372,15 @@ export class Call {
    * Leave the call and stop the media streams that were published by the call.
    */
   leave = async ({ reject = false }: CallLeaveOptions = {}) => {
-    // TODO: handle case when leave is called during JOINING
     const callingState = this.state.callingState;
     if (callingState === CallingState.LEFT) {
       throw new Error('Cannot leave call that has already been left.');
     }
 
+    if (callingState === CallingState.JOINING) {
+      await this.assertCallJoined();
+    }
+
     if (this.ringing) {
       // I'm the one who started the call, so I should cancel it.
       const hasOtherParticipants = this.state.remoteParticipants.length > 0;
@@ -804,6 +808,7 @@ export class Call {
     if (!this.publisher) {
       this.publisher = new Publisher({
         sfuClient,
+        dispatcher: this.dispatcher,
         state: this.state,
         connectionConfig,
         isDtxEnabled,
@@ -848,6 +853,7 @@ export class Call {
             subscriberSdp: sdp || '',
             clientDetails: getClientDetails(),
             migration,
+            fastReconnect: false,
           });
         });
 
@@ -928,14 +934,6 @@ export class Call {
     });
   };
 
-  private assertCallJoined = () => {
-    return new Promise<void>((resolve) => {
-      this.state.callingState$
-        .pipe(takeWhile((state) => state !== CallingState.JOINED, true))
-        .subscribe(() => resolve());
-    });
-  };
-
   /**
    * Starts publishing the given video stream to the call.
    * The stream will be stopped if the user changes an input device, or if the user leaves the call.
@@ -1221,6 +1219,17 @@ export class Call {
     return this.publisher?.updateVideoPublishQuality(enabledRids);
   };
 
+  private assertCallJoined = () => {
+    return new Promise<void>((resolve) => {
+      this.state.callingState$
+        .pipe(
+          takeWhile((state) => state !== CallingState.JOINED, true),
+          filter((s) => s === CallingState.JOINED),
+        )
+        .subscribe(() => resolve());
+    });
+  };
+
   /**
    * Sends a reaction to the other call participants.
    *

package/src/StreamSfuClient.ts

@@ -16,6 +16,7 @@ import {
 } from './rtc';
 import { JoinRequest, SfuRequest } from './gen/video/sfu/event/events';
 import {
+  ICERestartRequest,
   SendAnswerRequest,
   SetPublisherRequest,
   TrackSubscriptionDetails,
@@ -131,15 +132,14 @@ export class StreamSfuClient {
     this.edgeName = sfuServer.edge_name;
     this.token = token;
     this.logger = getLogger(['sfu-client']);
-    const logger = this.logger;
     const logInterceptor: RpcInterceptor = {
-      interceptUnary(
+      interceptUnary: (
         next: NextUnaryFn,
         method: MethodInfo,
         input: object,
         options: RpcOptions,
-      ): UnaryCall {
-        logger('trace', `Calling SFU RPC method ${method.name}`, {
+      ): UnaryCall => {
+        this.logger('trace', `Calling SFU RPC method ${method.name}`, {
           input,
           options,
         });
@@ -190,6 +190,7 @@ export class StreamSfuClient {
     code: number = 1000,
     reason: string = 'Requested signal connection close',
   ) => {
+    this.logger('debug', 'Closing SFU WS connection', code, reason);
     this.signalWs.close(code, reason);
 
     this.unsubscribeIceTrickle();
@@ -241,6 +242,17 @@ export class StreamSfuClient {
     );
   };
 
+  iceRestart = async (data: Omit<ICERestartRequest, 'sessionId'>) => {
+    return retryable(
+      () =>
+        this.rpc.iceRestart({
+          ...data,
+          sessionId: this.sessionId,
+        }),
+      this.logger,
+    );
+  };
+
   updateMuteState = async (trackType: TrackType, muted: boolean) => {
     return this.updateMuteStates({
       muteStates: [
@@ -319,7 +331,6 @@ export class StreamSfuClient {
           new Date().getTime() - this.lastMessageTimestamp.getTime();
 
         if (timeSinceLastMessage > this.unhealthyTimeoutInMs) {
-          this.logger('debug', 'SFU connection unhealthy, closing');
           this.close(
             4001,
             `SFU connection unhealthy. Didn't receive any healthcheck messages for ${this.unhealthyTimeoutInMs}ms`,

package/src/StreamVideoClient.ts

@@ -38,8 +38,7 @@ export class StreamVideoClient {
    * A reactive store that exposes all the state variables in a reactive manner - you can subscribe to changes of the different state variables. Our library is built in a way that all state changes are exposed in this store, so all UI changes in your application should be handled by subscribing to these variables.
    */
   readonly readOnlyStateStore: StreamVideoReadOnlyStateStore;
-  readonly user?: User;
-  readonly token?: TokenOrProvider;
+  readonly logLevel: LogLevel = 'warn';
   readonly logger: Logger;
 
   protected readonly writeableStateStore: StreamVideoWriteableStateStore;
@@ -109,17 +108,20 @@ export class StreamVideoClient {
             }.${sdkInfo.minor}.${sdkInfo.patch}`,
         );
       }
-      this.user = apiKeyOrArgs.user;
-      this.token = apiKeyOrArgs.token || apiKeyOrArgs.tokenProvider;
-      if (this.user) {
-        this.streamClient.startWaitingForConnection();
-      }
     }
 
     this.writeableStateStore = new StreamVideoWriteableStateStore();
     this.readOnlyStateStore = new StreamVideoReadOnlyStateStore(
       this.writeableStateStore,
     );
+
+    if (typeof apiKeyOrArgs !== 'string') {
+      const user = apiKeyOrArgs.user;
+      const token = apiKeyOrArgs.token || apiKeyOrArgs.tokenProvider;
+      if (user) {
+        this.connectUser(user, token);
+      }
+    }
   }
 
   /**
@@ -131,30 +133,30 @@ export class StreamVideoClient {
    * @param token a token or a function that returns a token.
    */
   async connectUser(
-    user?: User,
+    user: User,
     token?: TokenOrProvider,
   ): Promise<void | ConnectedEvent> {
-    const userToConnect = user || this.user;
-    const tokenToUse = token || this.token;
-    if (!userToConnect) {
-      throw new Error('Connect user is called without user');
-    }
-    if (userToConnect.type === 'anonymous') {
-      userToConnect.id = '!anon';
-      return this.connectAnonymousUser(userToConnect as UserWithId, tokenToUse);
+    if (user.type === 'anonymous') {
+      user.id = '!anon';
+      return this.connectAnonymousUser(user as UserWithId, token);
     }
-    if (userToConnect.type === 'guest') {
-      const response = await this.createGuestUser({
-        user: {
-          ...userToConnect,
-          role: 'guest',
-        },
-      });
-      return this.connectUser(response.user, response.access_token);
-    }
-    const connectUser = () => {
-      return this.streamClient.connectUser(userToConnect, tokenToUse);
+    let connectUser = () => {
+      return this.streamClient.connectUser(user, token);
     };
+    if (user.type === 'guest') {
+      connectUser = async () => {
+        const response = await this.createGuestUser({
+          user: {
+            ...user,
+            role: 'guest',
+          },
+        });
+        return this.streamClient.connectUser(
+          response.user,
+          response.access_token,
+        );
+      };
+    }
     this.connectionPromise = this.disconnectionPromise
       ? this.disconnectionPromise.then(() => connectUser())
       : connectUser();
@@ -199,7 +201,7 @@ export class StreamVideoClient {
       this.on('call.created', (event) => {
         if (event.type !== 'call.created') return;
         const { call, members } = event;
-        if (userToConnect.id === call.created_by.id) {
+        if (user.id === call.created_by.id) {
           this.logger(
             'warn',
             'Received `call.created` sent by the current user',
@@ -225,7 +227,7 @@ export class StreamVideoClient {
       this.on('call.ring', async (event) => {
         if (event.type !== 'call.ring') return;
         const { call, members } = event;
-        if (userToConnect.id === call.created_by.id) {
+        if (user.id === call.created_by.id) {
           this.logger(
             'debug',
             'Received `call.ring` sent by the current user so ignoring the event',
@@ -267,7 +269,7 @@ export class StreamVideoClient {
    *                https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
    */
   disconnectUser = async (timeout?: number) => {
-    if (!this.streamClient.user) {
+    if (!this.streamClient.user && !this.connectionPromise) {
       return;
     }
     const disconnectUser = () => this.streamClient.disconnectUser(timeout);