genesys-cloud-streaming-client 19.6.0 → 19.6.1-develop.17

package/dist/cjs/alerting-leader.d.ts

@@ -1,14 +1,26 @@
-import { IClientOptions, StreamingClientExtension } from './types/interfaces';
+/// <reference types="node" />
+import { IClientOptions, ILeaderStatus, StreamingClientExtension } from './types/interfaces';
 import { Client } from './client';
+import { EventEmitter } from 'events';
 import { NamedAgent } from './types/named-agent';
-export declare class AlertingLeaderExtension implements StreamingClientExtension {
+export declare class AlertingLeaderExtension extends EventEmitter implements StreamingClientExtension {
     private client;
     private connectionId?;
     private alertableInteractionTypes;
+    private abortController?;
+    private leaderStatus;
     constructor(client: Client, options: IClientOptions);
     handleStanzaInstanceChange(stanzaInstance: NamedAgent): void;
+    private setupAlertingLeader;
+    private subscribeToAlertingLeader;
     private markAsAlertable;
+    private getAlertingLeader;
+    private claimAlertingLeader;
     get expose(): AlertingLeaderApi;
 }
 export interface AlertingLeaderApi {
+    on: (event: string, handler: (...args: any) => void) => void;
+    off: (event: string, handler: (...args: any) => void) => void;
+    claimAlertingLeader(): Promise<void>;
+    leaderStatus: ILeaderStatus;
 }

package/dist/cjs/alerting-leader.js

@@ -1,20 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AlertingLeaderExtension = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const interfaces_1 = require("./types/interfaces");
+const events_1 = require("events");
 const utils_1 = require("./utils");
-class AlertingLeaderExtension {
+class AlertingLeaderExtension extends events_1.EventEmitter {
     constructor(client, options) {
         var _a;
+        super();
         this.client = client;
+        this.leaderStatus = {};
         this.alertableInteractionTypes = (_a = options.alertableInteractionTypes) !== null && _a !== void 0 ? _a : [];
     }
     handleStanzaInstanceChange(stanzaInstance) {
         var _a, _b;
         this.connectionId = (_b = (_a = stanzaInstance.transport) === null || _a === void 0 ? void 0 : _a.stream) === null || _b === void 0 ? void 0 : _b.id;
+        this.setupAlertingLeader();
+    }
+    async setupAlertingLeader() {
         if (this.alertableInteractionTypes.length !== 0) {
-            this.markAsAlertable();
+            try {
+                await this.subscribeToAlertingLeader();
+                await this.markAsAlertable();
+                await this.getAlertingLeader();
+            }
+            catch (err) {
+                this.client.logger.warn('Failed to setup alerting leader; falling back to the default of acting as the alerting leader');
+                // Fail 'open' so users don't miss calls
+                this.leaderStatus = { voice: { alerting: true, configured: false } };
+                this.emit('alertingLeaderChanged', this.leaderStatus);
+            }
         }
     }
+    async subscribeToAlertingLeader() {
+        const topic = `v2.users.${this.client.config.userId}.alertingleader`;
+        this.client.on(`notify:${topic}`, (event) => {
+            var _a, _b;
+            (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+            if ((_b = event.eventBody) === null || _b === void 0 ? void 0 : _b.connectionId) {
+                // We should alert if our connection is the alerting leader connection
+                const alerting = event.eventBody.connectionId === this.connectionId;
+                const clientType = event.eventBody.clientType;
+                let voice = { alerting, configured: true };
+                if (clientType) {
+                    voice = { ...voice, clientType };
+                }
+                this.leaderStatus = { voice };
+                this.emit('alertingLeaderChanged', this.leaderStatus);
+            }
+        });
+        return this.client._notifications._subscribeInternal(topic);
+    }
     async markAsAlertable() {
         const userId = this.client.config.userId;
         const connectionsRequestOptions = {
@@ -44,8 +82,61 @@ class AlertingLeaderExtension {
             this.client.logger.warn('Could not mark this connection as alertable; this client may not alert for incoming interactions');
         });
     }
+    async getAlertingLeader() {
+        this.abortController = new AbortController();
+        const leaderRequestOptions = {
+            method: 'get',
+            host: this.client.config.apiHost,
+            authToken: this.client.config.authToken,
+            logger: this.client.logger,
+            signal: this.abortController.signal
+        };
+        try {
+            const currentLeader = await this.client.http.requestApi('users/alertingleader', leaderRequestOptions);
+            // We should alert if our connection is the alerting leader connection
+            const alerting = currentLeader.data.connectionId === this.connectionId;
+            const clientType = currentLeader.data.clientType;
+            let voice = { alerting, configured: true };
+            if (clientType) {
+                voice = { ...voice, clientType };
+            }
+            this.leaderStatus = { voice };
+            this.emit('alertingLeaderChanged', this.leaderStatus);
+        }
+        catch (err) {
+            if (axios_1.default.isCancel(err)) {
+                return;
+            }
+            throw err;
+        }
+    }
+    async claimAlertingLeader() {
+        if (this.alertableInteractionTypes.length === 0) {
+            this.client.logger.info('This client is not configured for any alertable interactions and will not attempt to claim alerting leader');
+            throw new utils_1.StreamingClientError(interfaces_1.StreamingClientErrorTypes.generic, 'Unable to claim alerting leader; this client is not configured for any alertable interactions');
+        }
+        const leaderRequestOptions = {
+            method: 'put',
+            host: this.client.config.apiHost,
+            authToken: this.client.config.authToken,
+            logger: this.client.logger,
+            data: {
+                connectionId: this.connectionId
+            }
+        };
+        return this.client.http.requestApi('users/alertingleader', leaderRequestOptions)
+            .catch((err) => {
+            this.client.logger.warn('Unable to claim alerting leader; this client may not alert for incoming interactions');
+            throw new utils_1.StreamingClientError(interfaces_1.StreamingClientErrorTypes.generic, 'Unable to claim alerting leader', err);
+        });
+    }
     get expose() {
-        return {};
+        return {
+            on: this.on.bind(this),
+            off: this.off.bind(this),
+            claimAlertingLeader: this.claimAlertingLeader.bind(this),
+            leaderStatus: this.leaderStatus
+        };
     }
 }
 exports.AlertingLeaderExtension = AlertingLeaderExtension;

package/dist/cjs/client.js

@@ -670,7 +670,7 @@ class Client extends events_1.default {
         return Client.version;
     }
     static get version() {
-        return '19.6.0';
+        return '19.6.1';
     }
 }
 exports.Client = Client;

package/dist/cjs/http-client.js

@@ -64,7 +64,8 @@ class HttpClient {
             data: opts.data,
             responseType: opts.responseType,
             timeout: opts.requestTimeout || 30000,
-            headers
+            headers,
+            signal: opts.signal
         };
         // default to include auth header
         if (!opts.noAuthHeader) {

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

@@ -33,6 +33,27 @@ export interface ICustomHeader {
 export declare enum AlertableInteractionTypes {
     voice = "voice"
 }
+/** The alerting status for an interaction type */
+export interface IAlertingStatus {
+    /**
+     * Indicates whether this client should be alerting. This can be because this client is the alerting
+     * leader for this interaction type, alerting leader functionality is not configured by an admin,
+     * or because setup for alerting leader failed and we fallback to `alerting: true` so interactions
+     * don't go unnoticed.
+     */
+    alerting: boolean;
+    /**
+     * Indicates if alerting leader functionality is configured by an admin. This will also be `false`
+     * if setup for alerting leader failed.
+    */
+    configured: boolean;
+    /** A string representing the client type of the alerting leader, based on OAuth client ID. */
+    clientType?: string;
+}
+/** The alerting leader status for this client. Currently only `voice` interactions are supported. */
+export interface ILeaderStatus {
+    voice?: IAlertingStatus;
+}
 export interface IClientConfig {
     host: string;
     apiHost: string;
@@ -67,6 +88,7 @@ export declare type RequestApiOptions = {
     requestTimeout?: number;
     customHeaders?: ICustomHeader;
     maxAttempts?: number;
+    signal?: AbortSignal;
 };
 export interface IAxiosResponseError extends AxiosError {
     text: string;

package/dist/deploy-info.json

@@ -1,13 +1,13 @@
 {
-  "version": "19.6.0",
-  "build": "7",
-  "buildDate": "2026-04-17T16:20:47.432Z",
+  "version": "19.6.1-develop",
+  "build": "17",
+  "buildDate": "2026-04-29T14:55:47.312Z",
   "indexFiles": [
     {
-      "file": "v19.6.0/streaming-client.browser.js"
+      "file": "v19.6.1/streaming-client.browser.js"
     },
     {
-      "file": "v19.6.0/streaming-client.browser.js.LICENSE.txt"
+      "file": "v19.6.1/streaming-client.browser.js.LICENSE.txt"
     },
     {
       "file": "v19/streaming-client.browser.js"

package/dist/es/alerting-leader.d.ts

@@ -1,14 +1,26 @@
-import { IClientOptions, StreamingClientExtension } from './types/interfaces';
+/// <reference types="node" />
+import { IClientOptions, ILeaderStatus, StreamingClientExtension } from './types/interfaces';
 import { Client } from './client';
+import { EventEmitter } from 'events';
 import { NamedAgent } from './types/named-agent';
-export declare class AlertingLeaderExtension implements StreamingClientExtension {
+export declare class AlertingLeaderExtension extends EventEmitter implements StreamingClientExtension {
     private client;
     private connectionId?;
     private alertableInteractionTypes;
+    private abortController?;
+    private leaderStatus;
     constructor(client: Client, options: IClientOptions);
     handleStanzaInstanceChange(stanzaInstance: NamedAgent): void;
+    private setupAlertingLeader;
+    private subscribeToAlertingLeader;
     private markAsAlertable;
+    private getAlertingLeader;
+    private claimAlertingLeader;
     get expose(): AlertingLeaderApi;
 }
 export interface AlertingLeaderApi {
+    on: (event: string, handler: (...args: any) => void) => void;
+    off: (event: string, handler: (...args: any) => void) => void;
+    claimAlertingLeader(): Promise<void>;
+    leaderStatus: ILeaderStatus;
 }

package/dist/es/alerting-leader.js

@@ -1,17 +1,58 @@
 import { __awaiter } from "tslib";
-import { retryPromise } from './utils';
-export class AlertingLeaderExtension {
+import axios from 'axios';
+import { StreamingClientErrorTypes } from './types/interfaces';
+import { EventEmitter } from 'events';
+import { StreamingClientError, retryPromise } from './utils';
+export class AlertingLeaderExtension extends EventEmitter {
     constructor(client, options) {
         var _a;
+        super();
         this.client = client;
+        this.leaderStatus = {};
         this.alertableInteractionTypes = (_a = options.alertableInteractionTypes) !== null && _a !== void 0 ? _a : [];
     }
     handleStanzaInstanceChange(stanzaInstance) {
         var _a, _b;
         this.connectionId = (_b = (_a = stanzaInstance.transport) === null || _a === void 0 ? void 0 : _a.stream) === null || _b === void 0 ? void 0 : _b.id;
-        if (this.alertableInteractionTypes.length !== 0) {
-            this.markAsAlertable();
-        }
+        this.setupAlertingLeader();
+    }
+    setupAlertingLeader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.alertableInteractionTypes.length !== 0) {
+                try {
+                    yield this.subscribeToAlertingLeader();
+                    yield this.markAsAlertable();
+                    yield this.getAlertingLeader();
+                }
+                catch (err) {
+                    this.client.logger.warn('Failed to setup alerting leader; falling back to the default of acting as the alerting leader');
+                    // Fail 'open' so users don't miss calls
+                    this.leaderStatus = { voice: { alerting: true, configured: false } };
+                    this.emit('alertingLeaderChanged', this.leaderStatus);
+                }
+            }
+        });
+    }
+    subscribeToAlertingLeader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const topic = `v2.users.${this.client.config.userId}.alertingleader`;
+            this.client.on(`notify:${topic}`, (event) => {
+                var _a, _b;
+                (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+                if ((_b = event.eventBody) === null || _b === void 0 ? void 0 : _b.connectionId) {
+                    // We should alert if our connection is the alerting leader connection
+                    const alerting = event.eventBody.connectionId === this.connectionId;
+                    const clientType = event.eventBody.clientType;
+                    let voice = { alerting, configured: true };
+                    if (clientType) {
+                        voice = Object.assign(Object.assign({}, voice), { clientType });
+                    }
+                    this.leaderStatus = { voice };
+                    this.emit('alertingLeaderChanged', this.leaderStatus);
+                }
+            });
+            return this.client._notifications._subscribeInternal(topic);
+        });
     }
     markAsAlertable() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -44,7 +85,64 @@ export class AlertingLeaderExtension {
             });
         });
     }
+    getAlertingLeader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.abortController = new AbortController();
+            const leaderRequestOptions = {
+                method: 'get',
+                host: this.client.config.apiHost,
+                authToken: this.client.config.authToken,
+                logger: this.client.logger,
+                signal: this.abortController.signal
+            };
+            try {
+                const currentLeader = yield this.client.http.requestApi('users/alertingleader', leaderRequestOptions);
+                // We should alert if our connection is the alerting leader connection
+                const alerting = currentLeader.data.connectionId === this.connectionId;
+                const clientType = currentLeader.data.clientType;
+                let voice = { alerting, configured: true };
+                if (clientType) {
+                    voice = Object.assign(Object.assign({}, voice), { clientType });
+                }
+                this.leaderStatus = { voice };
+                this.emit('alertingLeaderChanged', this.leaderStatus);
+            }
+            catch (err) {
+                if (axios.isCancel(err)) {
+                    return;
+                }
+                throw err;
+            }
+        });
+    }
+    claimAlertingLeader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.alertableInteractionTypes.length === 0) {
+                this.client.logger.info('This client is not configured for any alertable interactions and will not attempt to claim alerting leader');
+                throw new StreamingClientError(StreamingClientErrorTypes.generic, 'Unable to claim alerting leader; this client is not configured for any alertable interactions');
+            }
+            const leaderRequestOptions = {
+                method: 'put',
+                host: this.client.config.apiHost,
+                authToken: this.client.config.authToken,
+                logger: this.client.logger,
+                data: {
+                    connectionId: this.connectionId
+                }
+            };
+            return this.client.http.requestApi('users/alertingleader', leaderRequestOptions)
+                .catch((err) => {
+                this.client.logger.warn('Unable to claim alerting leader; this client may not alert for incoming interactions');
+                throw new StreamingClientError(StreamingClientErrorTypes.generic, 'Unable to claim alerting leader', err);
+            });
+        });
+    }
     get expose() {
-        return {};
+        return {
+            on: this.on.bind(this),
+            off: this.off.bind(this),
+            claimAlertingLeader: this.claimAlertingLeader.bind(this),
+            leaderStatus: this.leaderStatus
+        };
     }
 }

package/dist/es/client.js

@@ -684,6 +684,6 @@ export class Client extends EventEmitter {
         return Client.version;
     }
     static get version() {
-        return '19.6.0';
+        return '19.6.1';
     }
 }

package/dist/es/http-client.js

@@ -54,7 +54,8 @@ export class HttpClient {
             data: opts.data,
             responseType: opts.responseType,
             timeout: opts.requestTimeout || 30000,
-            headers
+            headers,
+            signal: opts.signal
         };
         // default to include auth header
         if (!opts.noAuthHeader) {