@wazo/sdk 0.43.5 → 1.0.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wazo/sdk",
-  "version": "0.43.5",
+  "version": "1.0.0-alpha.0",
   "description": "Wazo's JavaScript Software Development Kit.",
   "main": "index.js",
   "types": "lib/types/index.d.ts",
@@ -59,7 +59,8 @@
     "reconnecting-websocket": "^4.4.0",
     "sdp-transform": "^2.14.2",
     "sip.js": "^0.21.2",
-    "webrtc-adapter": "^8.2.3"
+    "webrtc-adapter": "^8.2.3",
+    "xstate": "^5.13.2"
   },
   "devDependencies": {
     "@babel/core": "^7.24.4",

package/src/__tests__/__voice__/call.test.ts

@@ -0,0 +1,90 @@
+/* eslint-disable no-underscore-dangle */
+import { Inviter, UserAgent, type URI } from 'sip.js';
+
+import softphone from '../../voice/softphone';
+import Call from '../../voice/call';
+import { Actions, States } from '../../state-machine/call-state-machine';
+import { Actions as SoftphoneActions } from '../../state-machine/softphone-state-machine';
+
+import InvalidStateTransition from '../../domain/InvalidStateTransition';
+
+const uaOptions = {
+  logBuiltinEnabled: false,
+  transportOptions: {
+    traceSip: false,
+    wsServers: 'ws://localhost',
+  },
+};
+
+jest.mock('../..', () => ({
+  __esModule: true,
+  default: {
+    Auth: {
+      getHost: jest.fn(() => 'my-stack.io'),
+      getSession: jest.fn(() => ({
+        displayName: () => 'John Doe',
+        primaryWebRtcLine: () => ({}),
+      })),
+    },
+  },
+}));
+
+jest.mock('../../web-rtc-client', () => jest.fn().mockImplementation(() => ({
+  answer: jest.fn(() => Promise.resolve()),
+  hangup: jest.fn(() => Promise.resolve()),
+  register: jest.fn(() => Promise.resolve()),
+  setOnHeartbeatTimeout: jest.fn(() => Promise.resolve()),
+  setOnHeartbeatCallback: jest.fn(() => Promise.resolve()),
+  on: jest.fn(),
+})));
+
+const ua = new UserAgent(uaOptions);
+const sipCall = new Inviter(ua, UserAgent.makeURI('sip:1234@my.stack.io') as URI);
+
+softphone.connect();
+softphone._sendAction(SoftphoneActions.REGISTER_DONE);
+
+const invalidStateTransition = (state: string, action: string) => new InvalidStateTransition(`Invalid state transition from ${state} with action ${action}`, state, action);
+
+describe('Call', () => {
+  describe('accept', () => {
+    it('Should throw an error when accepting a not ringing call', async () => {
+      const call = new Call(sipCall, softphone);
+
+      await expect(call.accept()).rejects.toThrowError(invalidStateTransition(States.IDLE, Actions.ACCEPT));
+    });
+
+    it.only('Should throw an error when the softphone is not registered', async () => {
+      const call = new Call(sipCall, softphone);
+      call._sendAction(Actions.INCOMING_CALL);
+      softphone._sendAction(SoftphoneActions.TRANSPORT_CLOSED);
+
+      await expect(call.accept()).rejects.toThrowError(invalidStateTransition(States.RINGING, Actions.ACCEPT));
+    });
+
+    it('Should not throw an error when accepting a not ringing call', async () => {
+      const call = new Call(sipCall, softphone);
+      call._sendAction(Actions.INCOMING_CALL);
+
+      await call.accept();
+      expect(softphone.client.answer).toHaveBeenCalled();
+    });
+  });
+
+  describe('hangup', () => {
+    it('Should throw an error when terminating a non established call', async () => {
+      const call = new Call(sipCall, softphone);
+
+      await expect(call.hangup()).rejects.toThrowError(invalidStateTransition(States.IDLE, Actions.HANGUP));
+    });
+
+    it('Should not throw an error when terminating an established call', async () => {
+      const call = new Call(sipCall, softphone);
+      call._sendAction(Actions.MAKE_CALL);
+      call._sendAction(Actions.REMOTLY_ACCEPTED);
+
+      await call.hangup();
+      expect(softphone.client.hangup).toHaveBeenCalled();
+    });
+  });
+});

package/src/__tests__/__voice__/softphone.test.ts

@@ -0,0 +1,82 @@
+import { Softphone } from '../../voice/softphone';
+import { Actions, States } from '../../state-machine/softphone-state-machine';
+
+import Wazo from '../..';
+import InvalidStateTransition from '../../domain/InvalidStateTransition';
+
+const server = 'my.stack.io';
+const displayName = 'John Doe';
+const webRtcLine = {};
+const session = {
+  uuid: '1234',
+  displayName: jest.fn(() => displayName),
+  primaryWebRtcLine: jest.fn(() => webRtcLine),
+};
+
+jest.mock('../..', () => ({
+  __esModule: true,
+  default: {
+    Auth: {
+      getHost: jest.fn(() => server),
+      getSession: jest.fn(() => session),
+    },
+  },
+}));
+
+jest.mock('../../web-rtc-client', () => jest.fn().mockImplementation(() => ({
+  register: jest.fn(() => Promise.resolve()),
+  unregister: jest.fn(() => Promise.resolve()),
+  setOnHeartbeatTimeout: jest.fn(() => Promise.resolve()),
+  setOnHeartbeatCallback: jest.fn(() => Promise.resolve()),
+  on: jest.fn(),
+  INVITE: 'invite',
+})));
+
+const invalidStateTransition = (state: string, action: string) => new InvalidStateTransition(`Invalid state transition from ${state} with action ${action}`, state, action);
+
+describe('Softphone', () => {
+  describe('connect', () => {
+    it('Should retrieve information from Wazo.Auth', () => {
+      const instance = new Softphone();
+      jest.spyOn(instance, 'connectWithCredentials');
+      instance.connect({});
+
+      expect(Wazo.Auth.getHost).toHaveBeenCalled();
+      expect(Wazo.Auth.getSession).toHaveBeenCalled();
+      expect(instance.connectWithCredentials).toHaveBeenCalledWith(server, webRtcLine, displayName, { userUuid: session.uuid });
+      expect(instance.client.on).toHaveBeenCalledWith('invite', expect.anything());
+    });
+
+    it('Should throw an error when already connected', async () => {
+      const instance = new Softphone();
+      instance.softphoneActor.send({ type: Actions.REGISTER });
+
+      await expect(instance.connect({})).rejects.toThrowError(invalidStateTransition(States.REGISTERING, Actions.REGISTER));
+    });
+
+    it('Should not allow to register twice', async () => {
+      const instance = new Softphone();
+      instance.connect({});
+
+      await expect(instance.connect({})).rejects.toThrowError(invalidStateTransition(States.REGISTERING, Actions.REGISTER));
+    });
+  });
+
+  describe('disconnect', () => {
+    it('Should throw an error when not connected', async () => {
+      const instance = new Softphone();
+
+      await expect(instance.disconnect()).rejects.toThrowError(invalidStateTransition(States.UNREGISTERED, Actions.UNREGISTER));
+    });
+
+    it('Should unregister the client', async () => {
+      const instance = new Softphone();
+      instance.connect({});
+      instance.softphoneActor.send({ type: Actions.REGISTER_DONE });
+
+      await instance.disconnect();
+
+      expect(instance.client.unregister).toHaveBeenCalled();
+    });
+  });
+});

package/src/api/auth.ts

@@ -16,12 +16,6 @@ type LoginParams = {
   domainName?: string;
 };
 
-type SamlLoginBody = {
-  saml_session_id: string,
-  access_type?: 'online' | 'offline';
-  client_id?: string;
-};
-
 type SendResetPasswordArgs = {
   username?: string,
   email?: string,
@@ -117,15 +111,10 @@ export default ((client: ApiRequester, baseUrl: string): AuthD => ({
 
   logOut: (token: Token): Promise<LogoutResponse> => client.delete(`${baseUrl}/token/${token}`, null, {}, ApiRequester.successResponseParser),
   samlLogIn: async (samlSessionId: string): Promise<Session | null | undefined> => {
-    const body: SamlLoginBody = {
+    const body = {
       saml_session_id: samlSessionId,
     };
 
-    if (client.clientId) {
-      body.access_type = 'offline';
-      body.client_id = client.clientId;
-    }
-
     return client.post(`${baseUrl}/token`, body).then(Session.parse);
   },
   initiateIdpAuthentication: async (domain: string, redirectUrl: string) => {
@@ -139,7 +128,7 @@ export default ((client: ApiRequester, baseUrl: string): AuthD => ({
       'Content-Type': 'application/json',
     };
 
-    return client.post(`${baseUrl}/saml/sso`, body, headers);
+    return client.post(`${baseUrl}/saml/sso`, body, headers, (response: any) => response);
   },
   refreshToken: (refreshToken: string, backend: string, expiration: number, isMobile?: boolean, tenantId?: string, domainName?: string): Promise<Session | null | undefined> => {
     const body: Record<string, any> = {

package/src/checker/checks/webrtc.ts

@@ -1,4 +1,5 @@
 /* global MediaStream */
+import { getSipSessionId } from '../../utils/sdp';
 import WebRTCClient from '../../web-rtc-client';
 
 export default {
@@ -35,7 +36,7 @@ export default {
     client.on(client.REGISTERED, () => {
       const sipSession = client.call('*10');
 
-      if (!sipSession || !client.getSipSessionId(sipSession)) {
+      if (!sipSession || !getSipSessionId(sipSession)) {
         return handleError('Unable to make call through WebRTC');
       }
 

package/src/domain/InvalidState.ts

@@ -0,0 +1,13 @@
+class InvalidState extends Error {
+
+  state: string;
+
+  constructor(message: string, state: string) {
+    super(message);
+
+    this.state = state;
+  }
+
+}
+
+export default InvalidState;

package/src/domain/InvalidStateTransition.ts

@@ -0,0 +1,17 @@
+class InvalidStateTransition extends Error {
+
+  state: string;
+
+  action: string;
+
+  constructor(message: string, action: string, state: string) {
+    super(message);
+
+    this.action = action;
+
+    this.state = state;
+  }
+
+}
+
+export default InvalidStateTransition;

package/src/domain/Phone/WebRTCPhone.ts

@@ -12,6 +12,8 @@ import WazoWebRTCClient from '../../web-rtc-client';
 import Emitter from '../../utils/Emitter';
 import IssueReporter from '../../service/IssueReporter';
 import { PeerConnection, WazoSession } from '../types';
+import { getSipSessionId } from '../../utils/sdp';
+import { downgradeToAudio, getStreamFromConstraints, getWebRtcStats, setLocalMediaStream, upgradeToVideo } from '../../utils/webrtc';
 
 export const ON_USER_AGENT = 'onUserAgent';
 export const ON_REGISTERED = 'onRegistered';
@@ -282,7 +284,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
       id: callSession ? callSession.getId() : null,
       withMessage,
     });
-    this.client.downgradeToAudio(sipSession);
+    downgradeToAudio(sipSession);
 
     if (callSession) {
       callSession.cameraEnabled = false;
@@ -314,7 +316,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
     const desktop = constraints && constraints.desktop;
     const options = sipSession.sessionDescriptionHandlerOptionsReInvite;
     const wasAudioOnly = (options as SessionDescriptionHandlerOptions & { audioOnly: boolean })?.audioOnly;
-    const newStream = await this.client.upgradeToVideo(sipSession, constraints, isConference);
+    const newStream = await upgradeToVideo(sipSession, constraints, isConference);
 
     if (callSession) {
       callSession.cameraEnabled = true;
@@ -348,6 +350,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
       id: callSession ? callSession.getId() : null,
       isUpgrade,
     });
+
     // Have to send the message after a delay due to latency to update the remote peer
     setTimeout(() => {
       this.sendMessage(sipSession, JSON.stringify({
@@ -355,17 +358,16 @@ export default class WebRTCPhone extends Emitter implements Phone {
         content: {
           type: ON_MESSAGE_TRACK_UPDATED,
           update: isUpgrade ? 'upgrade' : 'downgrade',
-          sipCallId: sipSession && this.getSipSessionId(sipSession),
+          sipCallId: sipSession && getSipSessionId(sipSession),
           callId: callSession ? callSession.callId : null,
           number: callSession ? callSession.number : null,
-          callerNumber: callSession ? callSession.callerNumber : null,
         },
       }));
     }, 2500);
   }
 
   _bindEvents(sipSession: WazoSession) {
-    const sipSessionId = this.getSipSessionId(sipSession);
+    const sipSessionId = getSipSessionId(sipSession);
 
     if (sipSession instanceof Invitation) {
       // Monkey patch to know when canceled with the CANCEL message
@@ -433,7 +435,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
       const [stream] = event.streams;
       const kind = event && event.track && event.track.kind;
       logger.info('on track stream called on the peer connection', {
-        callId: this.getSipSessionId(sipSession),
+        callId: getSipSessionId(sipSession),
         streamId: stream ? stream.id : null,
         tracks: stream ? stream.getTracks() : null,
         kind,
@@ -460,7 +462,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
       constraints,
       id: callSession ? callSession.getId() : null,
     });
-    const screenShareStream = await this.client.getStreamFromConstraints(constraints);
+    const screenShareStream = await getStreamFromConstraints(constraints);
 
     if (!screenShareStream) {
       throw new Error(`Can't create media stream for screensharing with: ${JSON.stringify(constraints)}`);
@@ -468,9 +470,9 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
     const screenTrack = screenShareStream.getVideoTracks()[0];
     const sipSession = this.currentSipSession;
-    const pc = sipSession && this.client.getPeerConnection(this.getSipSessionId(sipSession));
+    const pc = sipSession && this.client.getPeerConnection(getSipSessionId(sipSession));
     const sender = pc && pc.getSenders && pc.getSenders().find((s) => s && s.track && s.track.kind === 'video');
-    const localStream = sipSession && this.client.getLocalStream(this.getSipSessionId(sipSession));
+    const localStream = sipSession && this.client.getLocalStream(getSipSessionId(sipSession));
     const videoTrack = localStream ? localStream.getTracks().find(track => track.kind === 'video') : null;
     const hadVideo = !!videoTrack;
 
@@ -545,12 +547,12 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
   _onScreenSharing(screenStream: MediaStream, sipSession: WazoSession, callSession: CallSession | null | undefined, hadVideo: boolean, desktop?: boolean | null | undefined) {
     const screenTrack = screenStream.getVideoTracks()[0];
-    const sipSessionId = this.getSipSessionId(sipSession);
+    const sipSessionId = getSipSessionId(sipSession);
     const pc = this.client.getPeerConnection(sipSessionId);
     const sender = pc && pc.getSenders && pc.getSenders().find((s) => s && s.track && s.track.kind === 'video');
     logger.info('WebRTC phone - on screensharing', {
       hadVideo,
-      id: this.getSipSessionId(sipSession),
+      id: getSipSessionId(sipSession),
       screenTrack,
     });
 
@@ -558,7 +560,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
       screenTrack.onended = () => {
         logger.info('WebRTC phone - on screenshare ended', {
           hadVideo,
-          id: this.getSipSessionId(sipSession),
+          id: getSipSessionId(sipSession),
           screenTrack,
         });
         this.eventEmitter.emit(ON_SHARE_SCREEN_ENDING, this._createCallSession(sipSession, callSession));
@@ -572,7 +574,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
       sipSessionId,
       desktop,
     };
-    this.client.setLocalMediaStream(this.getSipSessionId(sipSession), screenStream);
+    setLocalMediaStream(sipSession, screenStream);
     this.eventEmitter.emit(ON_SHARE_SCREEN_STARTED, this._createCallSession(sipSession, callSession, {
       screensharing: true,
     }), screenStream);
@@ -598,7 +600,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
     this.currentSipSession = sipSession;
     this.currentCallSession = callSession;
     this.eventEmitter.emit(ON_TERMINATE_SOUND, callSession, 'call accepted');
-    const sipSessionId = this.getSipSessionId(sipSession);
+    const sipSessionId = getSipSessionId(sipSession);
 
     if (sipSessionId) {
       this.removeIncomingSessions(sipSessionId);
@@ -670,7 +672,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
   }
 
   _onCallTerminated(sipSession: WazoSession): boolean {
-    const sipSessionId = this.getSipSessionId(sipSession);
+    const sipSessionId = getSipSessionId(sipSession);
 
     logger.info('WebRTC phone - on call terminated', {
       sipId: sipSession.id,
@@ -784,7 +786,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
       return false;
     }
 
-    return this.currentSipSession && this.getSipSessionId(this.currentSipSession) === callSession.getId();
+    return this.currentSipSession && getSipSessionId(this.currentSipSession) === callSession.getId();
   }
 
   hasVideo(callSession: CallSession): boolean {
@@ -976,7 +978,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
       return new Promise((resolve, reject) => reject(new Error('No session to hold')));
     }
 
-    const sessionId = this.getSipSessionId(sipSession);
+    const sessionId = getSipSessionId(sipSession);
     const hasVideo = this.client.hasLocalVideo(sessionId);
     logger.info('WebRTC hold sip session', {
       sipId: sipSession.id,
@@ -991,7 +993,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
     // Downgrade to audio if needed
     if (hasVideo) {
-      await this.client.downgradeToAudio(sipSession);
+      await downgradeToAudio(sipSession);
     }
 
     const isConference = !!callSession && callSession.isConference();
@@ -1010,7 +1012,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
     }
 
     const isConference = !!callSession && callSession.isConference();
-    const sessionId = this.getSipSessionId(sipSession);
+    const sessionId = getSipSessionId(sipSession);
     logger.info('WebRTC unhold sip session', {
       sessionId,
       isConference,
@@ -1029,7 +1031,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
         screen: wasScreensharing,
         desktop: wasDesktop,
       };
-      await this.client.upgradeToVideo(sipSession, constraints, isConference);
+      await upgradeToVideo(sipSession, constraints, isConference);
     }
 
     const onScreenSharing = (stream: MediaStream | null | undefined) => {
@@ -1292,7 +1294,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
       console.error('Call is unknown to the WebRTC phone', callSession ? callSession.sipCallId : null, callSession ? callSession.callId : null);
       return false;
     }
-    const sipSessionId = this.getSipSessionId(sipSession);
+    const sipSessionId = getSipSessionId(sipSession);
 
     logger.info('WebRTC hangup', {
       sipId: sipSession.id,
@@ -1313,7 +1315,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
   async getStats(callSession?: CallSession): Promise<RTCStatsReport | null | undefined> {
     const sipSession = this.findSipSession(callSession);
-    return sipSession ? this.client.getStats(sipSession) : null;
+    return sipSession ? getWebRtcStats(sipSession) : null;
   }
 
   startNetworkMonitoring(callSession?: CallSession, interval = 1000) {
@@ -1523,13 +1525,13 @@ export default class WebRTCPhone extends Emitter implements Phone {
       // if `_createCallSession` is called too soon `hasVideo` will return false because the stream doesn't exists yet
       setTimeout(() => {
         // Update callSession
-        this._createCallSession(sipSession, this.callSessions[this.getSipSessionId(sipSession)]);
+        this._createCallSession(sipSession, this.callSessions[getSipSessionId(sipSession)]);
 
         this.eventEmitter.emit.apply(this.eventEmitter, [this.client.ON_REINVITE, ...args]);
       }, 2000);
     });
     this.client.on(this.client.ACCEPTED, async (sipSession: WazoSession) => {
-      const sessionId = this.getSipSessionId(sipSession);
+      const sessionId = getSipSessionId(sipSession);
       const hasSession = (sessionId in this.callSessions);
       logger.info('WebRTC call accepted', {
         sipId: sessionId,
@@ -1561,7 +1563,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
       // `_createCallSession` add the CallSession in `this.callSessions`.
       // so we have to remove it or `callCount` will always return 1 even if the call was rejected
-      delete this.callSessions[this.getSipSessionId(session)];
+      delete this.callSessions[getSipSessionId(session)];
 
       callSession.endTime = new Date();
 
@@ -1581,7 +1583,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
       const callSession = this._createCallSession(session, null, {
         incoming: false,
         ringing: true,
-        callId: this.getSipSessionId(session),
+        callId: getSipSessionId(session),
       });
 
       this.eventEmitter.emit(ON_PROGRESS, callSession, this.audioOutputDeviceId, this.audioOutputVolume);
@@ -1592,7 +1594,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
       const callSession = this._createCallSession(session, null, {
         incoming: false,
         ringing: true,
-        callId: this.getSipSessionId(session),
+        callId: getSipSessionId(session),
       });
 
       this.eventEmitter.emit(ON_EARLY_MEDIA, callSession, this.audioOutputDeviceId, this.audioOutputVolume);
@@ -1653,12 +1655,12 @@ export default class WebRTCPhone extends Emitter implements Phone {
       this.eventEmitter.emit(ON_MESSAGE, message);
     });
     this.client.on(this.client.ON_NETWORK_STATS, (session, stats, previousStats) => {
-      const callSession = this.getCallSession(this.getSipSessionId(session));
+      const callSession = this.getCallSession(getSipSessionId(session));
       this.eventEmitter.emit(ON_NETWORK_STATS, callSession, stats, previousStats);
     });
     // Used when upgrading directly in screenshare mode
     this.client.on(this.client.ON_SCREEN_SHARING_REINVITE, (sipSession: WazoSession, response: any, desktop: boolean) => {
-      const sipSessionId = this.getSipSessionId(sipSession);
+      const sipSessionId = getSipSessionId(sipSession);
       const localStream = this.client.getLocalStream(sipSessionId);
       const callSession = this.callSessions[sipSessionId];
       logger.info('Updrading directly in screensharing mode', {
@@ -1676,7 +1678,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
     const keyIndex = keys.findIndex(sessionId => callSession && callSession.isId(sessionId));
 
     if (keyIndex === -1) {
-      const currentSipSessionId = this.currentSipSession ? this.getSipSessionId(this.currentSipSession) : this.client.getSipSessionIds()[0];
+      const currentSipSessionId = this.currentSipSession ? getSipSessionId(this.currentSipSession) : this.client.getSipSessionIds()[0];
       return currentSipSessionId ? this.client.getSipSession(currentSipSessionId) : null;
     }
 
@@ -1687,13 +1689,9 @@ export default class WebRTCPhone extends Emitter implements Phone {
     return this.callSessions[sipSessionId];
   }
 
-  getSipSessionId(sipSession: WazoSession): string {
-    return this.client.getSipSessionId(sipSession);
-  }
-
   getSipSessionIdFromCallSession(callSession: CallSession): string | null {
     const sipSession = this.findSipSession(callSession);
-    return sipSession ? this.getSipSessionId(sipSession) : null;
+    return sipSession ? getSipSessionId(sipSession) : null;
   }
 
   _updateCallSession(callSession: CallSession): void {
@@ -1792,7 +1790,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
     const {
       state,
     } = sipSession || {};
-    const sessionId = this.getSipSessionId(sipSession);
+    const sessionId = getSipSessionId(sipSession);
     fromSession = fromSession || this.callSessions[sessionId];
     const callSession = new CallSession({
       callId: fromSession && fromSession.callId,

package/src/domain/types.ts

@@ -264,12 +264,17 @@ export type PeerConnection = RTCPeerConnection & {
   addStream: (stream: MediaStream) => void;
   sfu: any;
 };
-
+// @TODO, rename it to SipCall
 export type WazoSession = (Invitation | Inviter) & {
   remoteTag?: any;
   callId?: string;
 };
 
+export type SipCall = (Invitation | Inviter) & {
+  remoteTag?: any;
+  callId?: string;
+};
+
 export type WazoTransport = Transport & {
   configuration: Record<string, any>;
   connectPromise: Promise<any>;

package/src/simple/Auth.ts

@@ -168,21 +168,28 @@ export class Auth {
   }
 
   async initiateIdpAuthentication(domain: string, redirectUrl: string): Promise<{ location: string, saml_session_id: string } | undefined> {
+    let response;
     try {
-      return await getApiClient().auth.initiateIdpAuthentication(domain, redirectUrl);
+      response = await getApiClient().auth.initiateIdpAuthentication(domain, redirectUrl);
     } catch (e: any) {
-      logger.error('Error during IdP authentication initialization:', e.message);
+      logger.error('Error during IdP authentication initiation:', e.message);
+      return;
+    }
 
-      if (e.status === 404) {
-        throw new NoSamlRouteError('No route found for SAML SSO');
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new NoSamlRouteError('No route found for saml sso');
       }
 
-      if (e.status === 500) {
+      if (response.status === 500) {
         throw new SamlConfigError('SAML/server configuration error');
       }
 
-      throw e;
+      const error = await response.json();
+      throw new Error(error.message || error.reason);
     }
+
+    return response.json();
   }
 
   async logInViaRefreshToken(refreshToken: string): Promise<Session | null> {

package/src/simple/Phone.ts

@@ -12,6 +12,7 @@ import Emitter from '../utils/Emitter';
 import Wazo from './index';
 import SFUNotAvailableError from '../domain/SFUNotAvailableError';
 import { WazoSession, WebRtcConfig } from '../domain/types';
+import { getSipSessionId } from '../utils/sdp';
 
 const logger = IssueReporter.loggerFor('simple-phone');
 const sipLogger = IssueReporter.loggerFor('sip.js');
@@ -332,7 +333,7 @@ export class Phone extends Emitter {
     if (!sipSession || !this.phone) {
       return null;
     }
-    return this.phone.getSipSessionId(sipSession);
+    return getSipSessionId(sipSession);
   }
 
   sendMessage(body: string, sipSession?: WazoSession, contentType = 'text/plain'): void {