genesys-cloud-streaming-client 15.1.0 → 15.1.2

package/dist/cjs/client.d.ts

@@ -22,6 +22,7 @@ export declare class Client extends EventEmitter {
     private autoReconnect;
     private extensions;
     private connectionManager;
+    private channelReuses;
     http: HttpClient;
     notifications: NotificationsAPI;
     _notifications: Notifications;

package/dist/cjs/client.js

@@ -22,6 +22,7 @@ let extensions = {
 };
 const STANZA_DISCONNECTED = 'stanzaDisconnected';
 const NO_LONGER_SUBSCRIBED = 'notify:no_longer_subscribed';
+const MAX_CHANNEL_REUSES = 10;
 class Client extends events_1.default {
     constructor(options) {
         super();
@@ -32,6 +33,7 @@ class Client extends events_1.default {
         this.backgroundAssistantMode = false;
         this.autoReconnect = true;
         this.extensions = [];
+        this.channelReuses = 0;
         this.http = new http_client_1.HttpClient();
         this.reconnectOnNoLongerSubscribed = options.reconnectOnNoLongerSubscribed !== false;
         this.config = {
@@ -179,20 +181,27 @@ class Client extends events_1.default {
             this.activeStanzaInstance.disconnect();
         }, 5000, 'disconnecting streaming service');
     }
-    async connect(connectOpts = { keepTryingOnFailure: false }) {
+    async connect(connectOpts) {
         var _a;
         if (this.connecting) {
             const error = new Error('Already trying to connect streaming client');
             return this.logger.warn(error);
         }
         this.connecting = true;
+        const maxDelay = (connectOpts === null || connectOpts === void 0 ? void 0 : connectOpts.maxDelayBetweenConnectionAttempts) || 90000;
+        let maxAttempts = (connectOpts === null || connectOpts === void 0 ? void 0 : connectOpts.maxConnectionAttempts) || 1;
+        // tslint:disable-next-line
+        if (connectOpts === null || connectOpts === void 0 ? void 0 : connectOpts.keepTryingOnFailure) {
+            // this maintains the previous functionality
+            maxAttempts = Infinity;
+        }
         try {
             await exponential_backoff_1.backOff(() => this.makeConnectionAttempt(), {
                 jitter: 'full',
-                maxDelay: 10000,
-                numOfAttempts: connectOpts.keepTryingOnFailure ? Infinity : 1,
+                maxDelay,
+                numOfAttempts: maxAttempts,
                 startingDelay: 2000,
-                retry: this.backoffConnectRetryHandler.bind(this, connectOpts)
+                retry: this.backoffConnectRetryHandler.bind(this, { maxConnectionAttempts: maxAttempts })
             });
         }
         catch (err) {
@@ -222,11 +231,11 @@ class Client extends events_1.default {
             throw err;
         }
     }
-    backoffConnectRetryHandler(connectOpts, err, connectionAttempt) {
-        var _a, _b;
+    async backoffConnectRetryHandler(connectOpts, err, connectionAttempt) {
+        var _a, _b, _c, _d, _e;
         // if we exceed the `numOfAttempts` in the backoff config it still calls this retry fn and just ignores the result
         // if that's the case, we just want to bail out and ignore all the extra logging here.
-        if (!connectOpts.keepTryingOnFailure) {
+        if (connectionAttempt >= connectOpts.maxConnectionAttempts) {
             return false;
         }
         const additionalErrorDetails = { connectionAttempt, error: err };
@@ -267,6 +276,22 @@ class Client extends events_1.default {
                 additionalErrorDetails.details = details;
             }
         }
+        if (err === null || err === void 0 ? void 0 : err.response) {
+            // This *should* be an axios error according to typings, but it appears this could be an AxiosError *or* and XmlHttpRequest
+            // we'll check both to be safe
+            const retryAfter = ((_c = err.response.headers) === null || _c === void 0 ? void 0 : _c['retry-after']) || ((_e = (_d = err.response).getResponseHeader) === null || _e === void 0 ? void 0 : _e.call(_d, 'retry-after'));
+            if (retryAfter) {
+                // retry after comes in seconds, we need to return milliseconds
+                let retryDelay = parseInt(retryAfter, 10) * 1000;
+                additionalErrorDetails.retryDelay = retryDelay;
+                this.logger.error('Failed streaming client connection attempt, respecting retry-after header and will retry afterwards.', additionalErrorDetails, { skipServer: err instanceof offline_error_1.default });
+                await new Promise((resolve) => {
+                    setTimeout(resolve, retryDelay);
+                });
+                this.logger.debug('finished waiting for retry-after');
+                return true;
+            }
+        }
         this.logger.error('Failed streaming client connection attempt, retrying', additionalErrorDetails, { skipServer: err instanceof offline_error_1.default });
         return true;
     }
@@ -274,28 +299,54 @@ class Client extends events_1.default {
         if (!navigator.onLine) {
             throw new offline_error_1.default('Browser is offline, skipping connection attempt');
         }
-        await this.prepareForConnect();
-        const stanzaInstance = await this.connectionManager.getNewStanzaConnection();
-        this.connected = true;
-        this.connecting = false;
-        this.addInateEventHandlers(stanzaInstance);
-        this.proxyStanzaEvents(stanzaInstance);
-        stanzaInstance.pinger = new ping_1.Ping(this, stanzaInstance);
-        // handle any extension configuration
-        for (const extension of this.extensions) {
-            if (extension.configureNewStanzaInstance) {
-                await extension.configureNewStanzaInstance(stanzaInstance);
+        let stanzaInstance;
+        let previousConnectingState = this.connecting;
+        try {
+            await this.prepareForConnect();
+            stanzaInstance = await this.connectionManager.getNewStanzaConnection();
+            this.connected = true;
+            this.connecting = false;
+            this.addInateEventHandlers(stanzaInstance);
+            this.proxyStanzaEvents(stanzaInstance);
+            stanzaInstance.pinger = new ping_1.Ping(this, stanzaInstance);
+            // handle any extension configuration
+            for (const extension of this.extensions) {
+                if (extension.configureNewStanzaInstance) {
+                    await extension.configureNewStanzaInstance(stanzaInstance);
+                }
+            }
+            for (const extension of this.extensions) {
+                extension.handleStanzaInstanceChange(stanzaInstance);
             }
+            this.activeStanzaInstance = stanzaInstance;
+            this.emit('connected');
+        }
+        catch (err) {
+            if (stanzaInstance) {
+                this.logger.error('Error occurred in connection attempt, but after websocket connected. Cleaning up connection so backoff is respected', { stanzaInstanceId: stanzaInstance.id, channelId: stanzaInstance.channelId });
+                // unproxy stanza events so we don't try and reconnect
+                stanzaInstance.emit = stanzaInstance.originalEmitter;
+                stanzaInstance.pinger.stop();
+                stanzaInstance.disconnect();
+                this.connected = false;
+                this.connecting = previousConnectingState;
+            }
+            throw err;
         }
-        this.extensions.forEach(extension => extension.handleStanzaInstanceChange(stanzaInstance));
-        this.activeStanzaInstance = stanzaInstance;
-        this.emit('connected');
     }
     async prepareForConnect() {
         if (this.config.jwt) {
             this.hardReconnectRequired = false;
             return this.connectionManager.setConfig(this.config);
         }
+        if (!this.hardReconnectRequired) {
+            this.channelReuses++;
+            if (this.channelReuses > MAX_CHANNEL_REUSES) {
+                this.logger.warn('Forcing a hard reconnect due to max channel reuses', { channelId: this.config.channelId, channelReuses: this.channelReuses });
+                this.channelReuses = 0;
+                this.hardReconnectRequired = true;
+            }
+        }
         if (this.hardReconnectRequired) {
             let jidPromise;
             if (this.config.jid) {
@@ -308,7 +359,7 @@ class Client extends events_1.default {
                     authToken: this.config.authToken,
                     logger: this.logger
                 };
-                jidPromise = this.http.requestApiWithRetry('users/me', jidRequestOpts).promise
+                jidPromise = this.http.requestApi('users/me', jidRequestOpts)
                     .then(res => res.data.chat.jabberId);
             }
             const channelRequestOpts = {
@@ -317,7 +368,7 @@ class Client extends events_1.default {
                 authToken: this.config.authToken,
                 logger: this.logger
             };
-            const channelPromise = this.http.requestApiWithRetry('notifications/channels?connectionType=streaming', channelRequestOpts).promise
+            const channelPromise = this.http.requestApi('notifications/channels?connectionType=streaming', channelRequestOpts)
                 .then(res => res.data.id);
             const [jid, channelId] = await Promise.all([jidPromise, channelPromise]);
             this.config.jid = jid;
@@ -351,7 +402,7 @@ class Client extends events_1.default {
         return Client.version;
     }
     static get version() {
-        return '15.1.0';
+        return '15.1.2';
     }
 }
 exports.Client = Client;

package/dist/cjs/http-client.js

@@ -11,12 +11,15 @@ class HttpClient {
     }
     requestApiWithRetry(path, opts, retryInterval) {
         const retry = utils_1.retryPromise(this.requestApi.bind(this, path, opts), (error) => {
-            var _a;
+            var _a, _b, _c;
             let retryValue = false;
             if (error === null || error === void 0 ? void 0 : error.response) {
                 retryValue = HttpClient.retryStatusCodes.has(error.response.status || 0);
-                const retryAfter = (_a = error.response.headers) === null || _a === void 0 ? void 0 : _a['retry-after'];
+                // This *should* be an axios error according to typings, but it appears this could be an AxiosError *or* and XmlHttpRequest
+                // we'll check both to be safe
+                const retryAfter = ((_a = error.response.headers) === null || _a === void 0 ? void 0 : _a['retry-after']) || ((_c = (_b = error.response).getResponseHeader) === null || _c === void 0 ? void 0 : _c.call(_b, 'retry-after'));
                 if (retryAfter) {
+                    (opts.logger || console).debug('retry-after header found on response. setting retry delay', { retryAfter });
                     // retry after comes in seconds, we need to return milliseconds
                     retryValue = parseInt(retryAfter, 10) * 1000;
                 }
@@ -51,6 +54,7 @@ class HttpClient {
             .then(boundHandler, boundHandler);
     }
     handleResponse(logger, start, params, res) {
+        var _a;
         let now = new Date().getTime();
         let elapsed = (now - start) + 'ms';
         if (res instanceof axios_1.AxiosError) {
@@ -70,7 +74,7 @@ class HttpClient {
             let body = response.data;
             let error = {
                 ...res,
-                text: response.request.response
+                text: (_a = response.request) === null || _a === void 0 ? void 0 : _a.response
             };
             logger.debug(`request error: ${params.url}`, {
                 message: res.message,

package/dist/cjs/ping.js

@@ -33,7 +33,8 @@ class Ping {
         catch (err) {
             const info = {
                 channelId: this.client.config.channelId,
-                jid: this.stanzaInstance.jid
+                jid: this.stanzaInstance.jid,
+                stanzaInstanceId: this.stanzaInstance.id
             };
             this.client.logger.warn('Missed a ping.', Object.assign({ error: err }, info));
             /* if we have reached max number of missed pings, disconnect */

package/dist/cjs/types/interfaces.d.ts

@@ -138,7 +138,12 @@ export interface StreamingClientExtension {
     expose: any;
 }
 export interface StreamingClientConnectOptions {
-    keepTryingOnFailure: boolean;
+    /**
+     * @deprecated since version 15.1.1. Please use maxConnectionAttempts instead
+     */
+    keepTryingOnFailure?: boolean;
+    maxConnectionAttempts?: number;
+    maxDelayBetweenConnectionAttempts?: number;
 }
 export interface GenesysWebrtcJsonRpcMessage extends JsonRpcMessage {
     id?: string;

package/dist/deploy-info.json

@@ -1,14 +1,14 @@
 {
   "name": "developercenter-cdn/streaming-client",
-  "version": "15.1.0",
+  "version": "15.1.2",
   "ecosystem": "pc",
   "team": "Genesys Client Media (WebRTC)",
   "indexFiles": [
     {
-      "file": "/v15.1.0/streaming-client.browser.ie.js"
+      "file": "/v15.1.2/streaming-client.browser.ie.js"
     },
     {
-      "file": "/v15.1.0/streaming-client.browser.js"
+      "file": "/v15.1.2/streaming-client.browser.js"
     },
     {
       "file": "/v15/streaming-client.browser.ie.js"
@@ -17,6 +17,6 @@
       "file": "/v15/streaming-client.browser.js"
     }
   ],
-  "build": "54",
-  "buildDate": "2023-02-22T18:01:39.328019Z"
+  "build": "57",
+  "buildDate": "2023-03-02T21:43:00.982202Z"
 }

package/dist/es/client.d.ts

@@ -22,6 +22,7 @@ export declare class Client extends EventEmitter {
     private autoReconnect;
     private extensions;
     private connectionManager;
+    private channelReuses;
     http: HttpClient;
     notifications: NotificationsAPI;
     _notifications: Notifications;

package/dist/es/client.js

@@ -20,6 +20,7 @@ let extensions = {
 };
 const STANZA_DISCONNECTED = 'stanzaDisconnected';
 const NO_LONGER_SUBSCRIBED = 'notify:no_longer_subscribed';
+const MAX_CHANNEL_REUSES = 10;
 export class Client extends EventEmitter {
     constructor(options) {
         super();
@@ -30,6 +31,7 @@ export class Client extends EventEmitter {
         this.backgroundAssistantMode = false;
         this.autoReconnect = true;
         this.extensions = [];
+        this.channelReuses = 0;
         this.http = new HttpClient();
         this.reconnectOnNoLongerSubscribed = options.reconnectOnNoLongerSubscribed !== false;
         this.config = {
@@ -181,7 +183,7 @@ export class Client extends EventEmitter {
             }, 5000, 'disconnecting streaming service');
         });
     }
-    connect(connectOpts = { keepTryingOnFailure: false }) {
+    connect(connectOpts) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (this.connecting) {
@@ -189,13 +191,20 @@ export class Client extends EventEmitter {
                 return this.logger.warn(error);
             }
             this.connecting = true;
+            const maxDelay = (connectOpts === null || connectOpts === void 0 ? void 0 : connectOpts.maxDelayBetweenConnectionAttempts) || 90000;
+            let maxAttempts = (connectOpts === null || connectOpts === void 0 ? void 0 : connectOpts.maxConnectionAttempts) || 1;
+            // tslint:disable-next-line
+            if (connectOpts === null || connectOpts === void 0 ? void 0 : connectOpts.keepTryingOnFailure) {
+                // this maintains the previous functionality
+                maxAttempts = Infinity;
+            }
             try {
                 yield backOff(() => this.makeConnectionAttempt(), {
                     jitter: 'full',
-                    maxDelay: 10000,
-                    numOfAttempts: connectOpts.keepTryingOnFailure ? Infinity : 1,
+                    maxDelay,
+                    numOfAttempts: maxAttempts,
                     startingDelay: 2000,
-                    retry: this.backoffConnectRetryHandler.bind(this, connectOpts)
+                    retry: this.backoffConnectRetryHandler.bind(this, { maxConnectionAttempts: maxAttempts })
                 });
             }
             catch (err) {
@@ -227,74 +236,110 @@ export class Client extends EventEmitter {
         });
     }
     backoffConnectRetryHandler(connectOpts, err, connectionAttempt) {
-        var _a, _b;
-        // if we exceed the `numOfAttempts` in the backoff config it still calls this retry fn and just ignores the result
-        // if that's the case, we just want to bail out and ignore all the extra logging here.
-        if (!connectOpts.keepTryingOnFailure) {
-            return false;
-        }
-        const additionalErrorDetails = { connectionAttempt, error: err };
-        if (!err) {
-            additionalErrorDetails.error = new Error('streaming client backoff handler received undefined error');
-        }
-        else if (err.name === 'AxiosError') {
-            const axiosError = err;
-            const config = axiosError.config;
-            let sanitizedError = {
-                config: {
-                    url: config.url,
-                    method: config.method
-                },
-                status: (_a = axiosError.response) === null || _a === void 0 ? void 0 : _a.status,
-                code: axiosError.code,
-                name: axiosError.name,
-                message: axiosError.message
-            };
-            additionalErrorDetails.error = sanitizedError;
-            if ([401, 403].includes(((_b = err.response) === null || _b === void 0 ? void 0 : _b.status) || 0)) {
-                this.logger.error('Streaming client received an error that it can\'t recover from and will not attempt to reconnect', additionalErrorDetails);
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            // if we exceed the `numOfAttempts` in the backoff config it still calls this retry fn and just ignores the result
+            // if that's the case, we just want to bail out and ignore all the extra logging here.
+            if (connectionAttempt >= connectOpts.maxConnectionAttempts) {
                 return false;
             }
-        }
-        // if we get a sasl error, that means we made it all the way to the point of trying to open a websocket and
-        // it was rejected for some reason. At this point we should do a hard reconnect then try again.
-        if (err instanceof SaslError) {
-            this.logger.info('hardReconnectRequired set to true due to sasl error');
-            this.hardReconnectRequired = true;
-            Object.assign(additionalErrorDetails, { channelId: err.channelId, stanzaInstanceId: err.stanzaInstanceId });
-        }
-        // we don't need to log the stack for a timeout message
-        if (err instanceof TimeoutError) {
-            additionalErrorDetails.error = err.message;
-            const details = err.details;
-            if (details) {
-                additionalErrorDetails.details = details;
+            const additionalErrorDetails = { connectionAttempt, error: err };
+            if (!err) {
+                additionalErrorDetails.error = new Error('streaming client backoff handler received undefined error');
             }
-        }
-        this.logger.error('Failed streaming client connection attempt, retrying', additionalErrorDetails, { skipServer: err instanceof OfflineError });
-        return true;
+            else if (err.name === 'AxiosError') {
+                const axiosError = err;
+                const config = axiosError.config;
+                let sanitizedError = {
+                    config: {
+                        url: config.url,
+                        method: config.method
+                    },
+                    status: (_a = axiosError.response) === null || _a === void 0 ? void 0 : _a.status,
+                    code: axiosError.code,
+                    name: axiosError.name,
+                    message: axiosError.message
+                };
+                additionalErrorDetails.error = sanitizedError;
+                if ([401, 403].includes(((_b = err.response) === null || _b === void 0 ? void 0 : _b.status) || 0)) {
+                    this.logger.error('Streaming client received an error that it can\'t recover from and will not attempt to reconnect', additionalErrorDetails);
+                    return false;
+                }
+            }
+            // if we get a sasl error, that means we made it all the way to the point of trying to open a websocket and
+            // it was rejected for some reason. At this point we should do a hard reconnect then try again.
+            if (err instanceof SaslError) {
+                this.logger.info('hardReconnectRequired set to true due to sasl error');
+                this.hardReconnectRequired = true;
+                Object.assign(additionalErrorDetails, { channelId: err.channelId, stanzaInstanceId: err.stanzaInstanceId });
+            }
+            // we don't need to log the stack for a timeout message
+            if (err instanceof TimeoutError) {
+                additionalErrorDetails.error = err.message;
+                const details = err.details;
+                if (details) {
+                    additionalErrorDetails.details = details;
+                }
+            }
+            if (err === null || err === void 0 ? void 0 : err.response) {
+                // This *should* be an axios error according to typings, but it appears this could be an AxiosError *or* and XmlHttpRequest
+                // we'll check both to be safe
+                const retryAfter = ((_c = err.response.headers) === null || _c === void 0 ? void 0 : _c['retry-after']) || ((_e = (_d = err.response).getResponseHeader) === null || _e === void 0 ? void 0 : _e.call(_d, 'retry-after'));
+                if (retryAfter) {
+                    // retry after comes in seconds, we need to return milliseconds
+                    let retryDelay = parseInt(retryAfter, 10) * 1000;
+                    additionalErrorDetails.retryDelay = retryDelay;
+                    this.logger.error('Failed streaming client connection attempt, respecting retry-after header and will retry afterwards.', additionalErrorDetails, { skipServer: err instanceof OfflineError });
+                    yield new Promise((resolve) => {
+                        setTimeout(resolve, retryDelay);
+                    });
+                    this.logger.debug('finished waiting for retry-after');
+                    return true;
+                }
+            }
+            this.logger.error('Failed streaming client connection attempt, retrying', additionalErrorDetails, { skipServer: err instanceof OfflineError });
+            return true;
+        });
     }
     makeConnectionAttempt() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!navigator.onLine) {
                 throw new OfflineError('Browser is offline, skipping connection attempt');
             }
-            yield this.prepareForConnect();
-            const stanzaInstance = yield this.connectionManager.getNewStanzaConnection();
-            this.connected = true;
-            this.connecting = false;
-            this.addInateEventHandlers(stanzaInstance);
-            this.proxyStanzaEvents(stanzaInstance);
-            stanzaInstance.pinger = new Ping(this, stanzaInstance);
-            // handle any extension configuration
-            for (const extension of this.extensions) {
-                if (extension.configureNewStanzaInstance) {
-                    yield extension.configureNewStanzaInstance(stanzaInstance);
+            let stanzaInstance;
+            let previousConnectingState = this.connecting;
+            try {
+                yield this.prepareForConnect();
+                stanzaInstance = yield this.connectionManager.getNewStanzaConnection();
+                this.connected = true;
+                this.connecting = false;
+                this.addInateEventHandlers(stanzaInstance);
+                this.proxyStanzaEvents(stanzaInstance);
+                stanzaInstance.pinger = new Ping(this, stanzaInstance);
+                // handle any extension configuration
+                for (const extension of this.extensions) {
+                    if (extension.configureNewStanzaInstance) {
+                        yield extension.configureNewStanzaInstance(stanzaInstance);
+                    }
+                }
+                for (const extension of this.extensions) {
+                    extension.handleStanzaInstanceChange(stanzaInstance);
                 }
+                this.activeStanzaInstance = stanzaInstance;
+                this.emit('connected');
+            }
+            catch (err) {
+                if (stanzaInstance) {
+                    this.logger.error('Error occurred in connection attempt, but after websocket connected. Cleaning up connection so backoff is respected', { stanzaInstanceId: stanzaInstance.id, channelId: stanzaInstance.channelId });
+                    // unproxy stanza events so we don't try and reconnect
+                    stanzaInstance.emit = stanzaInstance.originalEmitter;
+                    stanzaInstance.pinger.stop();
+                    stanzaInstance.disconnect();
+                    this.connected = false;
+                    this.connecting = previousConnectingState;
+                }
+                throw err;
             }
-            this.extensions.forEach(extension => extension.handleStanzaInstanceChange(stanzaInstance));
-            this.activeStanzaInstance = stanzaInstance;
-            this.emit('connected');
         });
     }
     prepareForConnect() {
@@ -303,6 +348,14 @@ export class Client extends EventEmitter {
                 this.hardReconnectRequired = false;
                 return this.connectionManager.setConfig(this.config);
             }
+            if (!this.hardReconnectRequired) {
+                this.channelReuses++;
+                if (this.channelReuses > MAX_CHANNEL_REUSES) {
+                    this.logger.warn('Forcing a hard reconnect due to max channel reuses', { channelId: this.config.channelId, channelReuses: this.channelReuses });
+                    this.channelReuses = 0;
+                    this.hardReconnectRequired = true;
+                }
+            }
             if (this.hardReconnectRequired) {
                 let jidPromise;
                 if (this.config.jid) {
@@ -315,7 +368,7 @@ export class Client extends EventEmitter {
                         authToken: this.config.authToken,
                         logger: this.logger
                     };
-                    jidPromise = this.http.requestApiWithRetry('users/me', jidRequestOpts).promise
+                    jidPromise = this.http.requestApi('users/me', jidRequestOpts)
                         .then(res => res.data.chat.jabberId);
                 }
                 const channelRequestOpts = {
@@ -324,7 +377,7 @@ export class Client extends EventEmitter {
                     authToken: this.config.authToken,
                     logger: this.logger
                 };
-                const channelPromise = this.http.requestApiWithRetry('notifications/channels?connectionType=streaming', channelRequestOpts).promise
+                const channelPromise = this.http.requestApi('notifications/channels?connectionType=streaming', channelRequestOpts)
                     .then(res => res.data.id);
                 const [jid, channelId] = yield Promise.all([jidPromise, channelPromise]);
                 this.config.jid = jid;
@@ -359,6 +412,6 @@ export class Client extends EventEmitter {
         return Client.version;
     }
     static get version() {
-        return '15.1.0';
+        return '15.1.2';
     }
 }

package/dist/es/http-client.js

@@ -7,12 +7,15 @@ export class HttpClient {
     }
     requestApiWithRetry(path, opts, retryInterval) {
         const retry = retryPromise(this.requestApi.bind(this, path, opts), (error) => {
-            var _a;
+            var _a, _b, _c;
             let retryValue = false;
             if (error === null || error === void 0 ? void 0 : error.response) {
                 retryValue = HttpClient.retryStatusCodes.has(error.response.status || 0);
-                const retryAfter = (_a = error.response.headers) === null || _a === void 0 ? void 0 : _a['retry-after'];
+                // This *should* be an axios error according to typings, but it appears this could be an AxiosError *or* and XmlHttpRequest
+                // we'll check both to be safe
+                const retryAfter = ((_a = error.response.headers) === null || _a === void 0 ? void 0 : _a['retry-after']) || ((_c = (_b = error.response).getResponseHeader) === null || _c === void 0 ? void 0 : _c.call(_b, 'retry-after'));
                 if (retryAfter) {
+                    (opts.logger || console).debug('retry-after header found on response. setting retry delay', { retryAfter });
                     // retry after comes in seconds, we need to return milliseconds
                     retryValue = parseInt(retryAfter, 10) * 1000;
                 }
@@ -47,6 +50,7 @@ export class HttpClient {
             .then(boundHandler, boundHandler);
     }
     handleResponse(logger, start, params, res) {
+        var _a;
         let now = new Date().getTime();
         let elapsed = (now - start) + 'ms';
         if (res instanceof AxiosError) {
@@ -64,7 +68,7 @@ export class HttpClient {
             let status = response.status;
             let correlationId = response.headers && response.headers[correlationIdHeaderName];
             let body = response.data;
-            let error = Object.assign(Object.assign({}, res), { text: response.request.response });
+            let error = Object.assign(Object.assign({}, res), { text: (_a = response.request) === null || _a === void 0 ? void 0 : _a.response });
             logger.debug(`request error: ${params.url}`, {
                 message: res.message,
                 now,