ue-softphone-sdk 2.2.3 → 2.2.5

package/src/core/user-agents/invite-user-agent-server.ts

@@ -0,0 +1,269 @@
+import { Dialog, SessionDialog } from "../dialogs";
+import { TransactionStateError } from "../exceptions";
+import {
+  IncomingInviteRequest,
+  IncomingRequestDelegate,
+  IncomingRequestMessage,
+  OutgoingResponse,
+  OutgoingResponseWithSession,
+  ResponseOptions,
+  URI
+} from "../messages";
+import { SignalingState } from "../session";
+import { InviteServerTransaction } from "../transactions";
+import { UserAgentCore } from "../user-agent-core";
+import { AllowedMethods } from "../user-agent-core/allowed-methods";
+import { UserAgentServer } from "./user-agent-server";
+
+/**
+ * INVITE UAS.
+ * @remarks
+ * 13 Initiating a Session
+ * https://tools.ietf.org/html/rfc3261#section-13
+ * 13.1 Overview
+ * https://tools.ietf.org/html/rfc3261#section-13.1
+ * 13.3 UAS Processing
+ * https://tools.ietf.org/html/rfc3261#section-13.3
+ * @public
+ */
+export class InviteUserAgentServer extends UserAgentServer implements IncomingInviteRequest {
+  /** The confirmed dialog, if any. */
+  private confirmedDialog: SessionDialog | undefined;
+  /** The early dialog, if any. */
+  private earlyDialog: SessionDialog | undefined;
+
+  constructor(protected core: UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate) {
+    super(InviteServerTransaction, core, message, delegate);
+  }
+
+  public dispose(): void {
+    if (this.earlyDialog) {
+      this.earlyDialog.dispose();
+    }
+    super.dispose();
+  }
+
+  /**
+   * 13.3.1.4 The INVITE is Accepted
+   * The UAS core generates a 2xx response.  This response establishes a
+   * dialog, and therefore follows the procedures of Section 12.1.1 in
+   * addition to those of Section 8.2.6.
+   * https://tools.ietf.org/html/rfc3261#section-13.3.1.4
+   * @param options - Accept options bucket.
+   */
+  public accept(options: ResponseOptions = { statusCode: 200 }): OutgoingResponseWithSession {
+    if (!this.acceptable) {
+      throw new TransactionStateError(`${this.message.method} not acceptable in state ${this.transaction.state}.`);
+    }
+
+    // This response establishes a dialog...
+    // https://tools.ietf.org/html/rfc3261#section-13.3.1.4
+    if (!this.confirmedDialog) {
+      if (this.earlyDialog) {
+        this.earlyDialog.confirm();
+        this.confirmedDialog = this.earlyDialog;
+        this.earlyDialog = undefined;
+      } else {
+        const transaction = this.transaction;
+        if (!(transaction instanceof InviteServerTransaction)) {
+          throw new Error("Transaction not instance of InviteClientTransaction.");
+        }
+        const state = Dialog.initialDialogStateForUserAgentServer(this.message, this.toTag);
+        this.confirmedDialog = new SessionDialog(transaction, this.core, state);
+      }
+    }
+
+    // When a UAS responds to a request with a response that establishes a
+    // dialog (such as a 2xx to INVITE), the UAS MUST copy all Record-Route
+    // header field values from the request into the response (including the
+    // URIs, URI parameters, and any Record-Route header field parameters,
+    // whether they are known or unknown to the UAS) and MUST maintain the
+    // order of those values.  The UAS MUST add a Contact header field to
+    // the response.  The Contact header field contains an address where the
+    // UAS would like to be contacted for subsequent requests in the dialog
+    // (which includes the ACK for a 2xx response in the case of an INVITE).
+    // Generally, the host portion of this URI is the IP address or FQDN of
+    // the host.  The URI provided in the Contact header field MUST be a SIP
+    // or SIPS URI.  If the request that initiated the dialog contained a
+    // SIPS URI in the Request-URI or in the top Record-Route header field
+    // value, if there was any, or the Contact header field if there was no
+    // Record-Route header field, the Contact header field in the response
+    // MUST be a SIPS URI.  The URI SHOULD have global scope (that is, the
+    // same URI can be used in messages outside this dialog).  The same way,
+    // the scope of the URI in the Contact header field of the INVITE is not
+    // limited to this dialog either.  It can therefore be used in messages
+    // to the UAC even outside this dialog.
+    // https://tools.ietf.org/html/rfc3261#section-12.1.1
+    const recordRouteHeader = this.message.getHeaders("record-route").map((header) => `Record-Route: ${header}`);
+    const contactHeader = `Contact: ${this.core.configuration.contact.toString()}`;
+
+    // A 2xx response to an INVITE SHOULD contain the Allow header field and
+    // the Supported header field, and MAY contain the Accept header field.
+    // Including these header fields allows the UAC to determine the
+    // features and extensions supported by the UAS for the duration of the
+    // call, without probing.
+    // https://tools.ietf.org/html/rfc3261#section-13.3.1.4
+
+    // FIXME: TODO: This should not be hard coded.
+    const allowHeader = "Allow: " + AllowedMethods.toString();
+
+    // FIXME: TODO: Supported header (see reply())
+
+    // FIXME: TODO: Accept header
+
+    // If the INVITE request contained an offer, and the UAS had not yet
+    // sent an answer, the 2xx MUST contain an answer.  If the INVITE did
+    // not contain an offer, the 2xx MUST contain an offer if the UAS had
+    // not yet sent an offer.
+    // https://tools.ietf.org/html/rfc3261#section-13.3.1.4
+    if (!options.body) {
+      if (this.confirmedDialog.signalingState === SignalingState.Stable) {
+        options.body = this.confirmedDialog.answer; // resend the answer sent in provisional response
+      } else if (
+        this.confirmedDialog.signalingState === SignalingState.Initial ||
+        this.confirmedDialog.signalingState === SignalingState.HaveRemoteOffer
+      ) {
+        throw new Error("Response must have a body.");
+      }
+    }
+
+    options.statusCode = options.statusCode || 200;
+    options.extraHeaders = options.extraHeaders || [];
+    options.extraHeaders = options.extraHeaders.concat(recordRouteHeader);
+    options.extraHeaders.push(allowHeader);
+    options.extraHeaders.push(contactHeader);
+
+    const response = super.accept(options);
+    const session = this.confirmedDialog;
+    const result: OutgoingResponseWithSession = { ...response, session };
+
+    // Update dialog signaling state
+    if (options.body) {
+      // Once the UAS has sent or received an answer to the initial
+      // offer, it MUST NOT generate subsequent offers in any responses
+      // to the initial INVITE.  This means that a UAS based on this
+      // specification alone can never generate subsequent offers until
+      // completion of the initial transaction.
+      // https://tools.ietf.org/html/rfc3261#section-13.2.1
+      if (this.confirmedDialog.signalingState !== SignalingState.Stable) {
+        this.confirmedDialog.signalingStateTransition(options.body);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * 13.3.1.1 Progress
+   * If the UAS is not able to answer the invitation immediately, it can
+   * choose to indicate some kind of progress to the UAC (for example, an
+   * indication that a phone is ringing).  This is accomplished with a
+   * provisional response between 101 and 199.  These provisional
+   * responses establish early dialogs and therefore follow the procedures
+   * of Section 12.1.1 in addition to those of Section 8.2.6.  A UAS MAY
+   * send as many provisional responses as it likes.  Each of these MUST
+   * indicate the same dialog ID.  However, these will not be delivered
+   * reliably.
+   *
+   * If the UAS desires an extended period of time to answer the INVITE,
+   * it will need to ask for an "extension" in order to prevent proxies
+   * from canceling the transaction.  A proxy has the option of canceling
+   * a transaction when there is a gap of 3 minutes between responses in a
+   * transaction.  To prevent cancellation, the UAS MUST send a non-100
+   * provisional response at every minute, to handle the possibility of
+   * lost provisional responses.
+   * https://tools.ietf.org/html/rfc3261#section-13.3.1.1
+   * @param options - Progress options bucket.
+   */
+  public progress(options: ResponseOptions = { statusCode: 180 }): OutgoingResponseWithSession {
+    if (!this.progressable) {
+      throw new TransactionStateError(`${this.message.method} not progressable in state ${this.transaction.state}.`);
+    }
+
+    // This response establishes a dialog...
+    // https://tools.ietf.org/html/rfc3261#section-13.3.1.4
+    if (!this.earlyDialog) {
+      const transaction = this.transaction;
+      if (!(transaction instanceof InviteServerTransaction)) {
+        throw new Error("Transaction not instance of InviteClientTransaction.");
+      }
+      const state = Dialog.initialDialogStateForUserAgentServer(this.message, this.toTag, true);
+      this.earlyDialog = new SessionDialog(transaction, this.core, state);
+    }
+
+    // When a UAS responds to a request with a response that establishes a
+    // dialog (such as a 2xx to INVITE), the UAS MUST copy all Record-Route
+    // header field values from the request into the response (including the
+    // URIs, URI parameters, and any Record-Route header field parameters,
+    // whether they are known or unknown to the UAS) and MUST maintain the
+    // order of those values.  The UAS MUST add a Contact header field to
+    // the response.  The Contact header field contains an address where the
+    // UAS would like to be contacted for subsequent requests in the dialog
+    // (which includes the ACK for a 2xx response in the case of an INVITE).
+    // Generally, the host portion of this URI is the IP address or FQDN of
+    // the host.  The URI provided in the Contact header field MUST be a SIP
+    // or SIPS URI.  If the request that initiated the dialog contained a
+    // SIPS URI in the Request-URI or in the top Record-Route header field
+    // value, if there was any, or the Contact header field if there was no
+    // Record-Route header field, the Contact header field in the response
+    // MUST be a SIPS URI.  The URI SHOULD have global scope (that is, the
+    // same URI can be used in messages outside this dialog).  The same way,
+    // the scope of the URI in the Contact header field of the INVITE is not
+    // limited to this dialog either.  It can therefore be used in messages
+    // to the UAC even outside this dialog.
+    // https://tools.ietf.org/html/rfc3261#section-12.1.1
+    const recordRouteHeader = this.message.getHeaders("record-route").map((header) => `Record-Route: ${header}`);
+    const contactHeader = `Contact: ${this.core.configuration.contact}`;
+
+    options.extraHeaders = options.extraHeaders || [];
+    options.extraHeaders = options.extraHeaders.concat(recordRouteHeader);
+    options.extraHeaders.push(contactHeader);
+
+    const response = super.progress(options);
+    const session = this.earlyDialog;
+    const result: OutgoingResponseWithSession = { ...response, session };
+
+    // Update dialog signaling state
+    if (options.body) {
+      // Once the UAS has sent or received an answer to the initial
+      // offer, it MUST NOT generate subsequent offers in any responses
+      // to the initial INVITE.  This means that a UAS based on this
+      // specification alone can never generate subsequent offers until
+      // completion of the initial transaction.
+      // https://tools.ietf.org/html/rfc3261#section-13.2.1
+      if (this.earlyDialog.signalingState !== SignalingState.Stable) {
+        this.earlyDialog.signalingStateTransition(options.body);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * 13.3.1.2 The INVITE is Redirected
+   * If the UAS decides to redirect the call, a 3xx response is sent.  A
+   * 300 (Multiple Choices), 301 (Moved Permanently) or 302 (Moved
+   * Temporarily) response SHOULD contain a Contact header field
+   * containing one or more URIs of new addresses to be tried.  The
+   * response is passed to the INVITE server transaction, which will deal
+   * with its retransmissions.
+   * https://tools.ietf.org/html/rfc3261#section-13.3.1.2
+   * @param contacts - Contacts to redirect to.
+   * @param options - Redirect options bucket.
+   */
+  public redirect(contacts: Array<URI>, options: ResponseOptions = { statusCode: 302 }): OutgoingResponse {
+    return super.redirect(contacts, options);
+  }
+
+  /**
+   * 13.3.1.3 The INVITE is Rejected
+   * A common scenario occurs when the callee is currently not willing or
+   * able to take additional calls at this end system.  A 486 (Busy Here)
+   * SHOULD be returned in such a scenario.
+   * https://tools.ietf.org/html/rfc3261#section-13.3.1.3
+   * @param options - Reject options bucket.
+   */
+  public reject(options: ResponseOptions = { statusCode: 486 }): OutgoingResponse {
+    return super.reject(options);
+  }
+}

package/src/core/user-agents/message-user-agent-client.ts

@@ -0,0 +1,14 @@
+import { OutgoingMessageRequest, OutgoingRequestDelegate, OutgoingRequestMessage } from "../messages";
+import { NonInviteClientTransaction } from "../transactions";
+import { UserAgentCore } from "../user-agent-core";
+import { UserAgentClient } from "./user-agent-client";
+
+/**
+ * MESSAGE UAC.
+ * @public
+ */
+export class MessageUserAgentClient extends UserAgentClient implements OutgoingMessageRequest {
+  constructor(core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate) {
+    super(NonInviteClientTransaction, core, message, delegate);
+  }
+}

package/src/core/user-agents/message-user-agent-server.ts

@@ -0,0 +1,14 @@
+import { IncomingMessageRequest, IncomingRequestDelegate, IncomingRequestMessage } from "../messages";
+import { NonInviteServerTransaction } from "../transactions";
+import { UserAgentCore } from "../user-agent-core";
+import { UserAgentServer } from "./user-agent-server";
+
+/**
+ * MESSAGE UAS.
+ * @public
+ */
+export class MessageUserAgentServer extends UserAgentServer implements IncomingMessageRequest {
+  constructor(core: UserAgentCore, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate) {
+    super(NonInviteServerTransaction, core, message, delegate);
+  }
+}

package/src/core/user-agents/notify-user-agent-client.ts

@@ -0,0 +1,15 @@
+import { SessionDialog } from "../dialogs";
+import { C, OutgoingNotifyRequest, OutgoingRequestDelegate, RequestOptions } from "../messages";
+import { NonInviteClientTransaction } from "../transactions";
+import { UserAgentClient } from "./user-agent-client";
+
+/**
+ * NOTIFY UAS.
+ * @public
+ */
+export class NotifyUserAgentClient extends UserAgentClient implements OutgoingNotifyRequest {
+  constructor(dialog: SessionDialog, delegate?: OutgoingRequestDelegate, options?: RequestOptions) {
+    const message = dialog.createOutgoingRequestMessage(C.NOTIFY, options);
+    super(NonInviteClientTransaction, dialog.userAgentCore, message, delegate);
+  }
+}

package/src/core/user-agents/notify-user-agent-server.ts

@@ -0,0 +1,30 @@
+import { Dialog } from "../dialogs";
+import { IncomingNotifyRequest, IncomingRequestDelegate, IncomingRequestMessage } from "../messages";
+import { NonInviteServerTransaction } from "../transactions";
+import { UserAgentCore } from "../user-agent-core";
+import { UserAgentServer } from "./user-agent-server";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function instanceOfDialog(object: any): object is Dialog {
+  return object.userAgentCore !== undefined;
+}
+
+/**
+ * NOTIFY UAS.
+ * @public
+ */
+export class NotifyUserAgentServer extends UserAgentServer implements IncomingNotifyRequest {
+  /**
+   * NOTIFY UAS constructor.
+   * @param dialogOrCore - Dialog for in dialog NOTIFY, UserAgentCore for out of dialog NOTIFY (deprecated).
+   * @param message - Incoming NOTIFY request message.
+   */
+  constructor(
+    dialogOrCore: Dialog | UserAgentCore,
+    message: IncomingRequestMessage,
+    delegate?: IncomingRequestDelegate
+  ) {
+    const userAgentCore = instanceOfDialog(dialogOrCore) ? dialogOrCore.userAgentCore : dialogOrCore;
+    super(NonInviteServerTransaction, userAgentCore, message, delegate);
+  }
+}

package/src/core/user-agents/prack-user-agent-client.ts

@@ -0,0 +1,16 @@
+import { SessionDialog } from "../dialogs";
+import { C, OutgoingPrackRequest, OutgoingRequestDelegate, RequestOptions } from "../messages";
+import { NonInviteClientTransaction } from "../transactions";
+import { UserAgentClient } from "./user-agent-client";
+
+/**
+ * PRACK UAC.
+ * @public
+ */
+export class PrackUserAgentClient extends UserAgentClient implements OutgoingPrackRequest {
+  constructor(dialog: SessionDialog, delegate?: OutgoingRequestDelegate, options?: RequestOptions) {
+    const message = dialog.createOutgoingRequestMessage(C.PRACK, options);
+    super(NonInviteClientTransaction, dialog.userAgentCore, message, delegate);
+    dialog.signalingStateTransition(message);
+  }
+}

package/src/core/user-agents/prack-user-agent-server.ts

@@ -0,0 +1,37 @@
+import { SessionDialog } from "../dialogs";
+import {
+  IncomingPrackRequest,
+  IncomingRequestDelegate,
+  IncomingRequestMessage,
+  OutgoingResponse,
+  ResponseOptions
+} from "../messages";
+import { NonInviteServerTransaction } from "../transactions";
+import { UserAgentServer } from "./user-agent-server";
+
+/**
+ * PRACK UAS.
+ * @public
+ */
+export class PrackUserAgentServer extends UserAgentServer implements IncomingPrackRequest {
+  private dialog: SessionDialog;
+
+  constructor(dialog: SessionDialog, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate) {
+    super(NonInviteServerTransaction, dialog.userAgentCore, message, delegate);
+    // Update dialog signaling state with offer/answer in body
+    dialog.signalingStateTransition(message);
+    this.dialog = dialog;
+  }
+
+  /**
+   * Update the dialog signaling state on a 2xx response.
+   * @param options - Options bucket.
+   */
+  public accept(options: ResponseOptions = { statusCode: 200 }): OutgoingResponse {
+    if (options.body) {
+      // Update dialog signaling state with offer/answer in body
+      this.dialog.signalingStateTransition(options.body);
+    }
+    return super.accept(options);
+  }
+}

package/src/core/user-agents/publish-user-agent-client.ts

@@ -0,0 +1,14 @@
+import { OutgoingPublishRequest, OutgoingRequestDelegate, OutgoingRequestMessage } from "../messages";
+import { NonInviteClientTransaction } from "../transactions";
+import { UserAgentCore } from "../user-agent-core";
+import { UserAgentClient } from "./user-agent-client";
+
+/**
+ * PUBLISH UAC.
+ * @public
+ */
+export class PublishUserAgentClient extends UserAgentClient implements OutgoingPublishRequest {
+  constructor(core: UserAgentCore, message: OutgoingRequestMessage, delegate?: OutgoingRequestDelegate) {
+    super(NonInviteClientTransaction, core, message, delegate);
+  }
+}

package/src/core/user-agents/re-invite-user-agent-client.ts

@@ -0,0 +1,127 @@
+import { SessionDialog } from "../dialogs";
+import {
+  C,
+  IncomingResponseMessage,
+  OutgoingAckRequest,
+  OutgoingInviteRequest,
+  OutgoingInviteRequestDelegate,
+  OutgoingPrackRequest,
+  RequestOptions
+} from "../messages";
+import { InviteClientTransaction } from "../transactions";
+import { UserAgentClient } from "./user-agent-client";
+
+/**
+ * Re-INVITE UAC.
+ * @remarks
+ * 14 Modifying an Existing Session
+ * https://tools.ietf.org/html/rfc3261#section-14
+ * 14.1 UAC Behavior
+ * https://tools.ietf.org/html/rfc3261#section-14.1
+ * @public
+ */
+export class ReInviteUserAgentClient extends UserAgentClient implements OutgoingInviteRequest {
+  public delegate: OutgoingInviteRequestDelegate | undefined;
+
+  private dialog: SessionDialog;
+
+  constructor(dialog: SessionDialog, delegate?: OutgoingInviteRequestDelegate, options?: RequestOptions) {
+    const message = dialog.createOutgoingRequestMessage(C.INVITE, options);
+    super(InviteClientTransaction, dialog.userAgentCore, message, delegate);
+    this.delegate = delegate;
+    dialog.signalingStateTransition(message);
+    // FIXME: TODO: next line obviously needs to be improved...
+    dialog.reinviteUserAgentClient = this; // let the dialog know re-invite request sent
+    this.dialog = dialog;
+  }
+
+  protected receiveResponse(message: IncomingResponseMessage): void {
+    if (!this.authenticationGuard(message, this.dialog)) {
+      return;
+    }
+
+    const statusCode = message.statusCode ? message.statusCode.toString() : "";
+    if (!statusCode) {
+      throw new Error("Response status code undefined.");
+    }
+
+    switch (true) {
+      case /^100$/.test(statusCode):
+        if (this.delegate && this.delegate.onTrying) {
+          this.delegate.onTrying({ message });
+        }
+        break;
+      case /^1[0-9]{2}$/.test(statusCode):
+        if (this.delegate && this.delegate.onProgress) {
+          this.delegate.onProgress({
+            message,
+            session: this.dialog,
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            prack: (options?: RequestOptions): OutgoingPrackRequest => {
+              throw new Error("Unimplemented.");
+            }
+          });
+        }
+        break;
+      case /^2[0-9]{2}$/.test(statusCode):
+        // Update dialog signaling state with offer/answer in body
+        this.dialog.signalingStateTransition(message);
+
+        if (this.delegate && this.delegate.onAccept) {
+          this.delegate.onAccept({
+            message,
+            session: this.dialog,
+            ack: (options?: RequestOptions): OutgoingAckRequest => {
+              const outgoingAckRequest = this.dialog.ack(options);
+              return outgoingAckRequest;
+            }
+          });
+        }
+        break;
+      case /^3[0-9]{2}$/.test(statusCode):
+        this.dialog.signalingStateRollback();
+        this.dialog.reinviteUserAgentClient = undefined; // ACK was handled by transaction
+
+        if (this.delegate && this.delegate.onRedirect) {
+          this.delegate.onRedirect({ message });
+        }
+        break;
+      case /^[4-6][0-9]{2}$/.test(statusCode):
+        this.dialog.signalingStateRollback();
+        this.dialog.reinviteUserAgentClient = undefined; // ACK was handled by transaction
+
+        if (this.delegate && this.delegate.onReject) {
+          this.delegate.onReject({ message });
+        } else {
+          // If a UA receives a non-2xx final response to a re-INVITE, the session
+          // parameters MUST remain unchanged, as if no re-INVITE had been issued.
+          // Note that, as stated in Section 12.2.1.2, if the non-2xx final
+          // response is a 481 (Call/Transaction Does Not Exist), or a 408
+          // (Request Timeout), or no response at all is received for the re-
+          // INVITE (that is, a timeout is returned by the INVITE client
+          // transaction), the UAC will terminate the dialog.
+          //
+          // If a UAC receives a 491 response to a re-INVITE, it SHOULD start a
+          // timer with a value T chosen as follows:
+          //
+          //    1. If the UAC is the owner of the Call-ID of the dialog ID
+          //       (meaning it generated the value), T has a randomly chosen value
+          //       between 2.1 and 4 seconds in units of 10 ms.
+          //
+          //    2. If the UAC is not the owner of the Call-ID of the dialog ID, T
+          //       has a randomly chosen value of between 0 and 2 seconds in units
+          //       of 10 ms.
+          //
+          // When the timer fires, the UAC SHOULD attempt the re-INVITE once more,
+          // if it still desires for that session modification to take place.  For
+          // example, if the call was already hung up with a BYE, the re-INVITE
+          // would not take place.
+          // https://tools.ietf.org/html/rfc3261#section-14.1
+          // FIXME: TODO: The above.
+        }
+        break;
+      default:
+        throw new Error(`Invalid status code ${statusCode}`);
+    }
+  }
+}

package/src/core/user-agents/re-invite-user-agent-server.ts

@@ -0,0 +1,109 @@
+import { SessionDialog } from "../dialogs";
+import {
+  IncomingInviteRequest,
+  IncomingRequestDelegate,
+  IncomingRequestMessage,
+  OutgoingResponse,
+  OutgoingResponseWithSession,
+  ResponseOptions,
+  URI
+} from "../messages";
+import { InviteServerTransaction } from "../transactions";
+import { UserAgentServer } from "./user-agent-server";
+
+/**
+ * Re-INVITE UAS.
+ * @remarks
+ * 14 Modifying an Existing Session
+ * https://tools.ietf.org/html/rfc3261#section-14
+ * 14.2 UAS Behavior
+ * https://tools.ietf.org/html/rfc3261#section-14.2
+ * @public
+ */
+export class ReInviteUserAgentServer extends UserAgentServer implements IncomingInviteRequest {
+  private dialog: SessionDialog;
+
+  constructor(dialog: SessionDialog, message: IncomingRequestMessage, delegate?: IncomingRequestDelegate) {
+    super(InviteServerTransaction, dialog.userAgentCore, message, delegate);
+    dialog.reinviteUserAgentServer = this;
+    this.dialog = dialog;
+  }
+
+  /**
+   * Update the dialog signaling state on a 2xx response.
+   * @param options - Options bucket.
+   */
+  public accept(options: ResponseOptions = { statusCode: 200 }): OutgoingResponseWithSession {
+    // FIXME: The next two lines SHOULD go away, but I suppose it's technically harmless...
+    // These are here because some versions of SIP.js prior to 0.13.8 set the route set
+    // of all in dialog ACKs based on the Record-Route headers in the associated 2xx
+    // response. While this worked for dialog forming 2xx responses, it was technically
+    // broken for re-INVITE ACKS as it only worked if the UAS populated the Record-Route
+    // headers in the re-INVITE 2xx response (which is not required and a waste of bandwidth
+    // as the should be ignored if present in re-INVITE ACKS) and the UAS populated
+    // the Record-Route headers with the correct values (would be weird not too, but...).
+    // Anyway, for now the technically useless Record-Route headers are being added
+    // to maintain "backwards compatibility" with the older broken versions of SIP.js.
+    options.extraHeaders = options.extraHeaders || [];
+    options.extraHeaders = options.extraHeaders.concat(this.dialog.routeSet.map((route) => `Record-Route: ${route}`));
+
+    // Send and return the response
+    const response = super.accept(options);
+    const session = this.dialog;
+    const result: OutgoingResponseWithSession = { ...response, session };
+
+    if (options.body) {
+      // Update dialog signaling state with offer/answer in body
+      this.dialog.signalingStateTransition(options.body);
+    }
+
+    // Update dialog
+    this.dialog.reConfirm();
+
+    return result;
+  }
+
+  /**
+   * Update the dialog signaling state on a 1xx response.
+   * @param options - Progress options bucket.
+   */
+  public progress(options: ResponseOptions = { statusCode: 180 }): OutgoingResponseWithSession {
+    // Send and return the response
+    const response = super.progress(options);
+    const session = this.dialog;
+    const result: OutgoingResponseWithSession = { ...response, session };
+
+    // Update dialog signaling state
+    if (options.body) {
+      this.dialog.signalingStateTransition(options.body);
+    }
+
+    return result;
+  }
+
+  /**
+   * TODO: Not Yet Supported
+   * @param contacts - Contacts to redirect to.
+   * @param options - Redirect options bucket.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public redirect(contacts: Array<URI>, options: ResponseOptions = { statusCode: 302 }): OutgoingResponse {
+    this.dialog.signalingStateRollback();
+    this.dialog.reinviteUserAgentServer = undefined; // ACK will be handled by transaction
+    throw new Error("Unimplemented.");
+  }
+
+  /**
+   * 3.1 Background on Re-INVITE Handling by UASs
+   * An error response to a re-INVITE has the following semantics.  As
+   * specified in Section 12.2.2 of RFC 3261 [RFC3261], if a re-INVITE is
+   * rejected, no state changes are performed.
+   * https://tools.ietf.org/html/rfc6141#section-3.1
+   * @param options - Reject options bucket.
+   */
+  public reject(options: ResponseOptions = { statusCode: 488 }): OutgoingResponse {
+    this.dialog.signalingStateRollback();
+    this.dialog.reinviteUserAgentServer = undefined; // ACK will be handled by transaction
+    return super.reject(options);
+  }
+}