ue-softphone-sdk 2.2.4 → 2.2.6

package/src/api/invitation.ts

@@ -1,816 +0,0 @@
-import {
-  Body,
-  fromBodyLegacy,
-  getBody,
-  Grammar,
-  IncomingInviteRequest,
-  IncomingPrackRequest,
-  IncomingRequestMessage,
-  InviteUserAgentServer,
-  Logger,
-  NameAddrHeader,
-  OutgoingResponse,
-  OutgoingResponseWithSession,
-  SignalingState,
-  Timers,
-  TransactionStateError
-} from "../core";
-import { getReasonPhrase } from "../core/messages/utils";
-import { ContentTypeUnsupportedError, SessionDescriptionHandlerError, SessionTerminatedError } from "./exceptions";
-import { InvitationAcceptOptions } from "./invitation-accept-options";
-import { InvitationProgressOptions } from "./invitation-progress-options";
-import { InvitationRejectOptions } from "./invitation-reject-options";
-import { Session } from "./session";
-import { SessionState } from "./session-state";
-import { UserAgent } from "./user-agent";
-import { SIPExtension } from "./user-agent-options";
-
-type ResolveFunction = () => void;
-type RejectFunction = (reason: Error) => void;
-
-/**
- * An invitation is an offer to establish a {@link Session} (incoming INVITE).
- * @public
- */
-export class Invitation extends Session {
-  /**
-   * Logger.
-   */
-  protected logger: Logger;
-
-  /** @internal */
-  protected _id: string;
-
-  /** True if dispose() has been called. */
-  private disposed = false;
-  /** INVITE will be rejected if not accepted within a certain period time. */
-  private expiresTimer: number | undefined = undefined;
-  /** True if this Session has been Terminated due to a CANCEL request. */
-  private isCanceled = false;
-  /** Are reliable provisional responses required or supported. */
-  private rel100: "none" | "required" | "supported" = "none";
-  /** The current RSeq header value. */
-  private rseq = Math.floor(Math.random() * 10000);
-  /** INVITE will be rejected if final response not sent in a certain period time. */
-  private userNoAnswerTimer: number | undefined = undefined;
-  /** True if waiting for a PRACK before sending a 200 Ok. */
-  private waitingForPrack = false;
-  /** A Promise providing a defer when waiting for a PRACK. */
-  private waitingForPrackPromise: Promise<void> | undefined;
-  /** Function to resolve when PRACK arrives. */
-  private waitingForPrackResolve: ResolveFunction | undefined;
-  /** Function to reject when PRACK never arrives. */
-  private waitingForPrackReject: RejectFunction | undefined;
-
-  /** @internal */
-  public constructor(userAgent: UserAgent, public incomingInviteRequest: IncomingInviteRequest) {
-    super(userAgent);
-
-    this.logger = userAgent.getLogger("sip.Invitation");
-
-    const incomingRequestMessage = this.incomingInviteRequest.message;
-
-    // Set 100rel if necessary
-    const requireHeader = incomingRequestMessage.getHeader("require");
-    if (requireHeader && requireHeader.toLowerCase().includes("100rel")) {
-      this.rel100 = "required";
-    }
-    const supportedHeader = incomingRequestMessage.getHeader("supported");
-    if (supportedHeader && supportedHeader.toLowerCase().includes("100rel")) {
-      this.rel100 = "supported";
-    }
-
-    // FIXME: HACK: This is a hack to port an existing behavior.
-    // Set the toTag on the incoming request message to the toTag which
-    // will be used in the response to the incoming request!!!
-    // The behavior being ported appears to be a hack itself,
-    // so this is a hack to port a hack. At least one test spec
-    // relies on it (which is yet another hack).
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    incomingRequestMessage.toTag = ((incomingInviteRequest as InviteUserAgentServer) as any).toTag;
-    if (typeof incomingRequestMessage.toTag !== "string") {
-      throw new TypeError("toTag should have been a string.");
-    }
-
-    // The following mapping values are RECOMMENDED:
-    // ...
-    // 19 no answer from the user              480 Temporarily unavailable
-    // https://tools.ietf.org/html/rfc3398#section-7.2.4.1
-    this.userNoAnswerTimer = window.setTimeout(
-      () => {
-        incomingInviteRequest.reject({ statusCode: 480 });
-        this.stateTransition(SessionState.Terminated);
-      },
-      this.userAgent.configuration.noAnswerTimeout ? this.userAgent.configuration.noAnswerTimeout * 1000 : 60000
-    );
-
-    // 1. If the request is an INVITE that contains an Expires header
-    // field, the UAS core sets a timer for the number of seconds
-    // indicated in the header field value.  When the timer fires, the
-    // invitation is considered to be expired.  If the invitation
-    // expires before the UAS has generated a final response, a 487
-    // (Request Terminated) response SHOULD be generated.
-    // https://tools.ietf.org/html/rfc3261#section-13.3.1
-    if (incomingRequestMessage.hasHeader("expires")) {
-      const expires: number = Number(incomingRequestMessage.getHeader("expires") || 0) * 1000;
-      this.expiresTimer = window.setTimeout(() => {
-        if (this.state === SessionState.Initial) {
-          incomingInviteRequest.reject({ statusCode: 487 });
-          this.stateTransition(SessionState.Terminated);
-        }
-      }, expires);
-    }
-
-    // Session parent properties
-    const assertedIdentity = this.request.getHeader("P-Asserted-Identity");
-    if (assertedIdentity) {
-      this._assertedIdentity = Grammar.nameAddrHeaderParse(assertedIdentity);
-    }
-    this._contact = this.userAgent.contact.toString();
-    const contentDisposition = incomingRequestMessage.parseHeader("Content-Disposition");
-    if (contentDisposition && contentDisposition.type === "render") {
-      this._renderbody = incomingRequestMessage.body;
-      this._rendertype = incomingRequestMessage.getHeader("Content-Type");
-    }
-
-    // Identifier
-    this._id = incomingRequestMessage.callId + incomingRequestMessage.fromTag;
-
-    // Add to the user agent's session collection.
-    this.userAgent._sessions[this._id] = this;
-  }
-
-  /**
-   * Destructor.
-   */
-  public dispose(): Promise<void> {
-    // Only run through this once. It can and does get called multiple times
-    // depending on the what the sessions state is when first called.
-    // For example, if called when "establishing" it will be called again
-    // at least once when the session transitions to "terminated".
-    // Regardless, running through this more than once is pointless.
-    if (this.disposed) {
-      return Promise.resolve();
-    }
-    this.disposed = true;
-
-    // Clear timers
-    if (this.expiresTimer) {
-      clearTimeout(this.expiresTimer);
-      this.expiresTimer = undefined;
-    }
-    if (this.userNoAnswerTimer) {
-      clearTimeout(this.userNoAnswerTimer);
-      this.userNoAnswerTimer = undefined;
-    }
-
-    // If accept() is still waiting for a PRACK, make sure it rejects
-    this.prackNeverArrived();
-
-    // If the final response for the initial INVITE not yet been sent, reject it
-    switch (this.state) {
-      case SessionState.Initial:
-        return this.reject().then(() => super.dispose());
-      case SessionState.Establishing:
-        return this.reject().then(() => super.dispose());
-      case SessionState.Established:
-        return super.dispose();
-      case SessionState.Terminating:
-        return super.dispose();
-      case SessionState.Terminated:
-        return super.dispose();
-      default:
-        throw new Error("Unknown state.");
-    }
-  }
-
-  /**
-   * If true, a first provisional response after the 100 Trying
-   * will be sent automatically. This is false it the UAC required
-   * reliable provisional responses (100rel in Require header) or
-   * the user agent configuration has specified to not send an
-   * initial response, otherwise it is true. The provisional is sent by
-   * calling `progress()` without any options.
-   */
-  public get autoSendAnInitialProvisionalResponse(): boolean {
-    return this.rel100 !== "required" && this.userAgent.configuration.sendInitialProvisionalResponse;
-  }
-
-  /**
-   * Initial incoming INVITE request message body.
-   */
-  public get body(): string | undefined {
-    return this.incomingInviteRequest.message.body;
-  }
-
-  /**
-   * The identity of the local user.
-   */
-  public get localIdentity(): NameAddrHeader {
-    return this.request.to;
-  }
-
-  /**
-   * The identity of the remote user.
-   */
-  public get remoteIdentity(): NameAddrHeader {
-    return this.request.from;
-  }
-
-  /**
-   * Initial incoming INVITE request message.
-   */
-  public get request(): IncomingRequestMessage {
-    return this.incomingInviteRequest.message;
-  }
-
-  /**
-   * Accept the invitation.
-   *
-   * @remarks
-   * Accept the incoming INVITE request to start a Session.
-   * Replies to the INVITE request with a 200 Ok response.
-   * Resolves once the response sent, otherwise rejects.
-   *
-   * This method may reject for a variety of reasons including
-   * the receipt of a CANCEL request before `accept` is able
-   * to construct a response.
-   * @param options - Options bucket.
-   */
-  public accept(options: InvitationAcceptOptions = {}): Promise<void> {
-    this.logger.log("Invitation.accept");
-
-    // validate state
-    if (this.state !== SessionState.Initial) {
-      const error = new Error(`Invalid session state ${this.state}`);
-      this.logger.error(error.message);
-      return Promise.reject(error);
-    }
-
-    // Modifiers and options for initial INVITE transaction
-    if (options.sessionDescriptionHandlerModifiers) {
-      this.sessionDescriptionHandlerModifiers = options.sessionDescriptionHandlerModifiers;
-    }
-    if (options.sessionDescriptionHandlerOptions) {
-      this.sessionDescriptionHandlerOptions = options.sessionDescriptionHandlerOptions;
-    }
-
-    // transition state
-    this.stateTransition(SessionState.Establishing);
-
-    return (
-      this.sendAccept(options)
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        .then(({ message, session }) => {
-          session.delegate = {
-            onAck: (ackRequest): Promise<void> => this.onAckRequest(ackRequest),
-            onAckTimeout: (): void => this.onAckTimeout(),
-            onBye: (byeRequest): void => this.onByeRequest(byeRequest),
-            onInfo: (infoRequest): void => this.onInfoRequest(infoRequest),
-            onInvite: (inviteRequest): void => this.onInviteRequest(inviteRequest),
-            onMessage: (messageRequest): void => this.onMessageRequest(messageRequest),
-            onNotify: (notifyRequest): void => this.onNotifyRequest(notifyRequest),
-            onPrack: (prackRequest): void => this.onPrackRequest(prackRequest),
-            onRefer: (referRequest): void => this.onReferRequest(referRequest)
-          };
-          this._dialog = session;
-          this.stateTransition(SessionState.Established);
-
-          // TODO: Reconsider this "automagic" send of a BYE to replacee behavior.
-          // This behavior has been ported forward from legacy versions.
-          if (this._replacee) {
-            this._replacee._bye();
-          }
-        })
-        .catch((error) => this.handleResponseError(error))
-    );
-  }
-
-  /**
-   * Indicate progress processing the invitation.
-   *
-   * @remarks
-   * Report progress to the the caller.
-   * Replies to the INVITE request with a 1xx provisional response.
-   * Resolves once the response sent, otherwise rejects.
-   * @param options - Options bucket.
-   */
-  public progress(options: InvitationProgressOptions = {}): Promise<void> {
-    this.logger.log("Invitation.progress");
-
-    // validate state
-    if (this.state !== SessionState.Initial) {
-      const error = new Error(`Invalid session state ${this.state}`);
-      this.logger.error(error.message);
-      return Promise.reject(error);
-    }
-
-    // Ported
-    const statusCode = options.statusCode || 180;
-    if (statusCode < 100 || statusCode > 199) {
-      throw new TypeError("Invalid statusCode: " + statusCode);
-    }
-
-    // Modifiers and options for initial INVITE transaction
-    if (options.sessionDescriptionHandlerModifiers) {
-      this.sessionDescriptionHandlerModifiers = options.sessionDescriptionHandlerModifiers;
-    }
-    if (options.sessionDescriptionHandlerOptions) {
-      this.sessionDescriptionHandlerOptions = options.sessionDescriptionHandlerOptions;
-    }
-
-    // After the first reliable provisional response for a request has been
-    // acknowledged, the UAS MAY send additional reliable provisional
-    // responses.  The UAS MUST NOT send a second reliable provisional
-    // response until the first is acknowledged.  After the first, it is
-    // RECOMMENDED that the UAS not send an additional reliable provisional
-    // response until the previous is acknowledged.  The first reliable
-    // provisional response receives special treatment because it conveys
-    // the initial sequence number.  If additional reliable provisional
-    // responses were sent before the first was acknowledged, the UAS could
-    // not be certain these were received in order.
-    // https://tools.ietf.org/html/rfc3262#section-3
-    if (this.waitingForPrack) {
-      this.logger.warn("Unexpected call for progress while waiting for prack, ignoring");
-      return Promise.resolve();
-    }
-
-    // Trying provisional response
-    if (options.statusCode === 100) {
-      return this.sendProgressTrying()
-        .then(() => {
-          return;
-        })
-        .catch((error) => this.handleResponseError(error));
-    }
-
-    // Standard provisional response
-    if (
-      !(this.rel100 === "required") &&
-      !(this.rel100 === "supported" && options.rel100) &&
-      !(this.rel100 === "supported" && this.userAgent.configuration.sipExtension100rel === SIPExtension.Required)
-    ) {
-      return this.sendProgress(options)
-        .then(() => {
-          return;
-        })
-        .catch((error) => this.handleResponseError(error));
-    }
-
-    // Reliable provisional response
-    return this.sendProgressReliableWaitForPrack(options)
-      .then(() => {
-        return;
-      })
-      .catch((error) => this.handleResponseError(error));
-  }
-
-  /**
-   * Reject the invitation.
-   *
-   * @remarks
-   * Replies to the INVITE request with a 4xx, 5xx, or 6xx final response.
-   * Resolves once the response sent, otherwise rejects.
-   *
-   * The expectation is that this method is used to reject an INVITE request.
-   * That is indeed the case - a call to `progress` followed by `reject` is
-   * a typical way to "decline" an incoming INVITE request. However it may
-   * also be called after calling `accept` (but only before it completes)
-   * which will reject the call and cause `accept` to reject.
-   * @param options - Options bucket.
-   */
-  public reject(options: InvitationRejectOptions = {}): Promise<void> {
-    this.logger.log("Invitation.reject");
-
-    // validate state
-    if (this.state !== SessionState.Initial && this.state !== SessionState.Establishing) {
-      const error = new Error(`Invalid session state ${this.state}`);
-      this.logger.error(error.message);
-      return Promise.reject(error);
-    }
-
-    const statusCode = options.statusCode || 480;
-
-    const reasonPhrase = options.reasonPhrase ? options.reasonPhrase : getReasonPhrase(statusCode);
-    const extraHeaders = options.extraHeaders || [];
-
-    if (statusCode < 300 || statusCode > 699) {
-      throw new TypeError("Invalid statusCode: " + statusCode);
-    }
-
-    const body = options.body ? fromBodyLegacy(options.body) : undefined;
-
-    // FIXME: Need to redirect to someplace
-    statusCode < 400
-      ? this.incomingInviteRequest.redirect([], { statusCode, reasonPhrase, extraHeaders, body })
-      : this.incomingInviteRequest.reject({ statusCode, reasonPhrase, extraHeaders, body });
-
-    this.stateTransition(SessionState.Terminated);
-
-    return Promise.resolve();
-  }
-
-  /**
-   * Handle CANCEL request.
-   *
-   * @param message - CANCEL message.
-   * @internal
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public _onCancel(message: IncomingRequestMessage): void {
-    this.logger.log("Invitation._onCancel");
-
-    // validate state
-    if (this.state !== SessionState.Initial && this.state !== SessionState.Establishing) {
-      this.logger.error(`CANCEL received while in state ${this.state}, dropping request`);
-      return;
-    }
-
-    // flag canceled
-    this.isCanceled = true;
-
-    // reject INVITE with 487 status code
-    this.incomingInviteRequest.reject({ statusCode: 487 });
-
-    this.stateTransition(SessionState.Terminated);
-  }
-
-  /**
-   * Helper function to handle offer/answer in a PRACK.
-   */
-  private handlePrackOfferAnswer(request: IncomingPrackRequest): Promise<Body | undefined> {
-    if (!this.dialog) {
-      throw new Error("Dialog undefined.");
-    }
-
-    // If the PRACK doesn't have an offer/answer, nothing to be done.
-    const body = getBody(request.message);
-    if (!body || body.contentDisposition !== "session") {
-      return Promise.resolve(undefined);
-    }
-
-    const options = {
-      sessionDescriptionHandlerOptions: this.sessionDescriptionHandlerOptions,
-      sessionDescriptionHandlerModifiers: this.sessionDescriptionHandlerModifiers
-    };
-
-    // If the UAC receives a reliable provisional response with an offer
-    // (this would occur if the UAC sent an INVITE without an offer, in
-    // which case the first reliable provisional response will contain the
-    // offer), it MUST generate an answer in the PRACK.  If the UAC receives
-    // a reliable provisional response with an answer, it MAY generate an
-    // additional offer in the PRACK.  If the UAS receives a PRACK with an
-    // offer, it MUST place the answer in the 2xx to the PRACK.
-    // https://tools.ietf.org/html/rfc3262#section-5
-    switch (this.dialog.signalingState) {
-      case SignalingState.Initial:
-        // State should never be reached as first reliable provisional response must have answer/offer.
-        throw new Error(`Invalid signaling state ${this.dialog.signalingState}.`);
-      case SignalingState.Stable:
-        // Receved answer.
-        return this.setAnswer(body, options).then(() => undefined);
-      case SignalingState.HaveLocalOffer:
-        // State should never be reached as local offer would be answered by this PRACK
-        throw new Error(`Invalid signaling state ${this.dialog.signalingState}.`);
-      case SignalingState.HaveRemoteOffer:
-        // Received offer, generate answer.
-        return this.setOfferAndGetAnswer(body, options);
-      case SignalingState.Closed:
-        throw new Error(`Invalid signaling state ${this.dialog.signalingState}.`);
-      default:
-        throw new Error(`Invalid signaling state ${this.dialog.signalingState}.`);
-    }
-  }
-
-  /**
-   * A handler for errors which occur while attempting to send 1xx and 2xx responses.
-   * In all cases, an attempt is made to reject the request if it is still outstanding.
-   * And while there are a variety of things which can go wrong and we log something here
-   * for all errors, there are a handful of common exceptions we pay some extra attention to.
-   * @param error - The error which occurred.
-   */
-  private handleResponseError(error: Error): void {
-    let statusCode = 480; // "Temporarily Unavailable"
-
-    // Log Error message
-    if (error instanceof Error) {
-      this.logger.error(error.message);
-    } else {
-      // We don't actually know what a session description handler implementation might throw our way,
-      // and more generally as a last resort catch all, just assume we are getting an "unknown" and log it.
-      this.logger.error((error as unknown) as string);
-    }
-
-    // Log Exception message
-    if (error instanceof ContentTypeUnsupportedError) {
-      this.logger.error("A session description handler occurred while sending response (content type unsupported");
-      statusCode = 415; // "Unsupported Media Type"
-    } else if (error instanceof SessionDescriptionHandlerError) {
-      this.logger.error("A session description handler occurred while sending response");
-    } else if (error instanceof SessionTerminatedError) {
-      this.logger.error("Session ended before response could be formulated and sent (while waiting for PRACK)");
-    } else if (error instanceof TransactionStateError) {
-      this.logger.error("Session changed state before response could be formulated and sent");
-    }
-
-    // Reject if still in "initial" or "establishing" state.
-    if (this.state === SessionState.Initial || this.state === SessionState.Establishing) {
-      try {
-        this.incomingInviteRequest.reject({ statusCode });
-        this.stateTransition(SessionState.Terminated);
-      } catch (e) {
-        this.logger.error("An error occurred attempting to reject the request while handling another error");
-        throw e; // This is not a good place to be...
-      }
-    }
-
-    // FIXME: TODO:
-    // Here we are squelching the throwing of errors due to an race condition.
-    // We have an internal race between calling `accept()` and handling an incoming
-    // CANCEL request. As there is no good way currently to delegate the handling of
-    // these race errors to the caller of `accept()`, we are squelching the throwing
-    // of ALL errors when/if they occur after receiving a CANCEL to catch the ONE we know
-    // is a "normal" exceptional condition. While this is a completely reasonable approach,
-    // the decision should be left up to the library user. Furthermore, as we are eating
-    // ALL errors in this case, we are potentially (likely) hiding "real" errors which occur.
-    //
-    // Only rethrow error if the session has not been canceled.
-    if (this.isCanceled) {
-      this.logger.warn(
-        "An error occurred while attempting to formulate and send a response to an incoming INVITE." +
-          " However a CANCEL was received and processed while doing so which can (and often does) result" +
-          " in errors occurring as the session terminates in the meantime. Said error is being ignored."
-      );
-      return;
-    }
-
-    throw error;
-  }
-
-  /**
-   * Callback for when ACK for a 2xx response is never received.
-   * @param session - Session the ACK never arrived for.
-   */
-  private onAckTimeout(): void {
-    this.logger.log("Invitation.onAckTimeout");
-    if (!this.dialog) {
-      throw new Error("Dialog undefined.");
-    }
-    this.logger.log("No ACK received for an extended period of time, terminating session");
-    this.dialog.bye();
-    this.stateTransition(SessionState.Terminated);
-  }
-
-  /**
-   * A version of `accept` which resolves a session when the 200 Ok response is sent.
-   * @param options - Options bucket.
-   */
-  private sendAccept(options: InvitationAcceptOptions = {}): Promise<OutgoingResponseWithSession> {
-    const responseOptions = {
-      sessionDescriptionHandlerOptions: this.sessionDescriptionHandlerOptions,
-      sessionDescriptionHandlerModifiers: this.sessionDescriptionHandlerModifiers
-    };
-
-    const extraHeaders = options.extraHeaders || [];
-
-    // The UAS MAY send a final response to the initial request before
-    // having received PRACKs for all unacknowledged reliable provisional
-    // responses, unless the final response is 2xx and any of the
-    // unacknowledged reliable provisional responses contained a session
-    // description.  In that case, it MUST NOT send a final response until
-    // those provisional responses are acknowledged.  If the UAS does send a
-    // final response when reliable responses are still unacknowledged, it
-    // SHOULD NOT continue to retransmit the unacknowledged reliable
-    // provisional responses, but it MUST be prepared to process PRACK
-    // requests for those outstanding responses.  A UAS MUST NOT send new
-    // reliable provisional responses (as opposed to retransmissions of
-    // unacknowledged ones) after sending a final response to a request.
-    // https://tools.ietf.org/html/rfc3262#section-3
-    if (this.waitingForPrack) {
-      return this.waitForArrivalOfPrack()
-        .then(() => clearTimeout(this.userNoAnswerTimer)) // Ported
-        .then(() => this.generateResponseOfferAnswer(this.incomingInviteRequest, responseOptions))
-        .then((body) => this.incomingInviteRequest.accept({ statusCode: 200, body, extraHeaders }));
-    }
-
-    clearTimeout(this.userNoAnswerTimer); // Ported
-    return this.generateResponseOfferAnswer(this.incomingInviteRequest, responseOptions).then((body) =>
-      this.incomingInviteRequest.accept({ statusCode: 200, body, extraHeaders })
-    );
-  }
-
-  /**
-   * A version of `progress` which resolves when the provisional response is sent.
-   * @param options - Options bucket.
-   */
-  private sendProgress(options: InvitationProgressOptions = {}): Promise<OutgoingResponseWithSession> {
-    const statusCode = options.statusCode || 180;
-    const reasonPhrase = options.reasonPhrase;
-    const extraHeaders = (options.extraHeaders || []).slice();
-    const body = options.body ? fromBodyLegacy(options.body) : undefined;
-
-    // The 183 (Session Progress) response is used to convey information
-    // about the progress of the call that is not otherwise classified.  The
-    // Reason-Phrase, header fields, or message body MAY be used to convey
-    // more details about the call progress.
-    // https://tools.ietf.org/html/rfc3261#section-21.1.5
-
-    // It is the de facto industry standard to utilize 183 with SDP to provide "early media".
-    // While it is unlikely someone would want to send a 183 without SDP, so it should be an option.
-    if (statusCode === 183 && !body) {
-      return this.sendProgressWithSDP(options);
-    }
-
-    try {
-      const progressResponse = this.incomingInviteRequest.progress({ statusCode, reasonPhrase, extraHeaders, body });
-      this._dialog = progressResponse.session;
-      return Promise.resolve(progressResponse);
-    } catch (error) {
-      return Promise.reject(error);
-    }
-  }
-
-  /**
-   * A version of `progress` which resolves when the provisional response with sdp is sent.
-   * @param options - Options bucket.
-   */
-  private sendProgressWithSDP(options: InvitationProgressOptions = {}): Promise<OutgoingResponseWithSession> {
-    const responseOptions = {
-      sessionDescriptionHandlerOptions: this.sessionDescriptionHandlerOptions,
-      sessionDescriptionHandlerModifiers: this.sessionDescriptionHandlerModifiers
-    };
-    const statusCode = options.statusCode || 183;
-    const reasonPhrase = options.reasonPhrase;
-    const extraHeaders = (options.extraHeaders || []).slice();
-
-    // Get an offer/answer and send a reply.
-    return this.generateResponseOfferAnswer(this.incomingInviteRequest, responseOptions)
-      .then((body) => this.incomingInviteRequest.progress({ statusCode, reasonPhrase, extraHeaders, body }))
-      .then((progressResponse) => {
-        this._dialog = progressResponse.session;
-        return progressResponse;
-      });
-  }
-
-  /**
-   * A version of `progress` which resolves when the reliable provisional response is sent.
-   * @param options - Options bucket.
-   */
-  private sendProgressReliable(options: InvitationProgressOptions = {}): Promise<OutgoingResponseWithSession> {
-    options.extraHeaders = (options.extraHeaders || []).slice();
-    options.extraHeaders.push("Require: 100rel");
-    options.extraHeaders.push("RSeq: " + Math.floor(Math.random() * 10000));
-    return this.sendProgressWithSDP(options);
-  }
-
-  /**
-   * A version of `progress` which resolves when the reliable provisional response is acknowledged.
-   * @param options - Options bucket.
-   */
-  private sendProgressReliableWaitForPrack(
-    options: InvitationProgressOptions = {}
-  ): Promise<{
-    prackRequest: IncomingPrackRequest;
-    prackResponse: OutgoingResponse;
-    progressResponse: OutgoingResponseWithSession;
-  }> {
-    const responseOptions = {
-      sessionDescriptionHandlerOptions: this.sessionDescriptionHandlerOptions,
-      sessionDescriptionHandlerModifiers: this.sessionDescriptionHandlerModifiers
-    };
-    const statusCode = options.statusCode || 183;
-    const reasonPhrase = options.reasonPhrase;
-    const extraHeaders: Array<string> = (options.extraHeaders || []).slice();
-    extraHeaders.push("Require: 100rel");
-    extraHeaders.push("RSeq: " + this.rseq++);
-    let body: Body | undefined;
-
-    return new Promise((resolve, reject) => {
-      this.waitingForPrack = true;
-      this.generateResponseOfferAnswer(this.incomingInviteRequest, responseOptions)
-        .then((offerAnswer) => {
-          body = offerAnswer;
-          return this.incomingInviteRequest.progress({ statusCode, reasonPhrase, extraHeaders, body });
-        })
-        .then((progressResponse) => {
-          this._dialog = progressResponse.session;
-
-          let prackRequest: IncomingPrackRequest;
-          let prackResponse: OutgoingResponse;
-          progressResponse.session.delegate = {
-            onPrack: (request): void => {
-              prackRequest = request;
-              // eslint-disable-next-line @typescript-eslint/no-use-before-define
-              clearTimeout(prackWaitTimeoutTimer);
-              // eslint-disable-next-line @typescript-eslint/no-use-before-define
-              clearTimeout(rel1xxRetransmissionTimer);
-              if (!this.waitingForPrack) {
-                return;
-              }
-              this.waitingForPrack = false;
-              this.handlePrackOfferAnswer(prackRequest)
-                .then((prackResponseBody) => {
-                  try {
-                    prackResponse = prackRequest.accept({ statusCode: 200, body: prackResponseBody });
-                    this.prackArrived();
-                    resolve({ prackRequest, prackResponse, progressResponse });
-                  } catch (error) {
-                    reject(error);
-                  }
-                })
-                .catch((error: Error) => reject(error));
-            }
-          };
-
-          // https://tools.ietf.org/html/rfc3262#section-3
-          const prackWaitTimeout = (): void => {
-            if (!this.waitingForPrack) {
-              return;
-            }
-            this.waitingForPrack = false;
-            this.logger.warn("No PRACK received, rejecting INVITE.");
-            // eslint-disable-next-line @typescript-eslint/no-use-before-define
-            clearTimeout(rel1xxRetransmissionTimer);
-            this.reject({ statusCode: 504 })
-              .then(() => reject(new SessionTerminatedError()))
-              .catch((error: Error) => reject(error));
-          };
-          const prackWaitTimeoutTimer = window.setTimeout(prackWaitTimeout, Timers.T1 * 64);
-
-          // https://tools.ietf.org/html/rfc3262#section-3
-          const rel1xxRetransmission = (): void => {
-            try {
-              this.incomingInviteRequest.progress({ statusCode, reasonPhrase, extraHeaders, body });
-            } catch (error) {
-              this.waitingForPrack = false;
-              reject(error);
-              return;
-            }
-            // eslint-disable-next-line @typescript-eslint/no-use-before-define
-            rel1xxRetransmissionTimer = window.setTimeout(rel1xxRetransmission, (timeout *= 2));
-          };
-          let timeout = Timers.T1;
-          let rel1xxRetransmissionTimer = window.setTimeout(rel1xxRetransmission, timeout);
-        })
-        .catch((error: Error) => {
-          this.waitingForPrack = false;
-          reject(error);
-        });
-    });
-  }
-
-  /**
-   * A version of `progress` which resolves when a 100 Trying provisional response is sent.
-   */
-  private sendProgressTrying(): Promise<OutgoingResponse> {
-    try {
-      const progressResponse = this.incomingInviteRequest.trying();
-      return Promise.resolve(progressResponse);
-    } catch (error) {
-      return Promise.reject(error);
-    }
-  }
-
-  /**
-   * When attempting to accept the INVITE, an invitation waits
-   * for any outstanding PRACK to arrive before sending the 200 Ok.
-   * It will be waiting on this Promise to resolve which lets it know
-   * the PRACK has arrived and it may proceed to send the 200 Ok.
-   */
-  private waitForArrivalOfPrack(): Promise<void> {
-    if (this.waitingForPrackPromise) {
-      throw new Error("Already waiting for PRACK");
-    }
-    this.waitingForPrackPromise = new Promise<void>((resolve, reject) => {
-      this.waitingForPrackResolve = resolve;
-      this.waitingForPrackReject = reject;
-    });
-    return this.waitingForPrackPromise;
-  }
-
-  /**
-   * Here we are resolving the promise which in turn will cause
-   * the accept to proceed (it may still fail for other reasons, but...).
-   */
-  private prackArrived(): void {
-    if (this.waitingForPrackResolve) {
-      this.waitingForPrackResolve();
-    }
-    this.waitingForPrackPromise = undefined;
-    this.waitingForPrackResolve = undefined;
-    this.waitingForPrackReject = undefined;
-  }
-
-  /**
-   * Here we are rejecting the promise which in turn will cause
-   * the accept to fail and the session to transition to "terminated".
-   */
-  private prackNeverArrived(): void {
-    if (this.waitingForPrackReject) {
-      this.waitingForPrackReject(new SessionTerminatedError());
-    }
-    this.waitingForPrackPromise = undefined;
-    this.waitingForPrackResolve = undefined;
-    this.waitingForPrackReject = undefined;
-  }
-}