@cognigy/rest-api-client 0.13.2 → 0.15.0

package/build/shared/charts/descriptors/voice/mappers/record.mapper.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordMapper = void 0;
+/* Custom modules */
+const logger_1 = require("../../../../helper/logger");
+const base_mapper_1 = require("./base.mapper");
+class RecordMapper extends base_mapper_1.BaseMapper {
+    handleInput(input, api, isGenericNode = false) {
+        try {
+            switch (this.endpointType) {
+                case "audioCodes": {
+                    const output = this.handleAudioCodesInput(input, api);
+                    return this.buildPayload(output);
+                }
+                case "voiceGateway2":
+                default: {
+                    const output = this.handleVGInput(input, api);
+                    return this.buildPayload(output);
+                }
+            }
+        }
+        catch (err) {
+            const errorMessage = `Error in RecordMapper handleInput: ${err.message}`;
+            api.log("error", errorMessage);
+            throw Error(errorMessage);
+        }
+    }
+    handleVGInput(input, api) {
+        const { action, recordingId, siprecServerURL } = input;
+        /* base record options */
+        const recordOptions = {
+            action,
+        };
+        const storedActivity = api.getSystemContext("vgRecordAction");
+        if (recordingId) {
+            recordOptions.recordingID = recordingId;
+        }
+        switch (action) {
+            case "startCallRecording":
+                if (process.env.TMP_ENDPOINT_CALL_RECORDING_ENABLE_GLOBALLY !== "true") {
+                    if (storedActivity === "startCallRecording") {
+                        const errorText = "Cannot start recording when recording is already started";
+                        logger_1.default.error({}, errorText, {}, true);
+                        throw new Error(errorText);
+                    }
+                    else if (storedActivity === "resumeCallRecording") {
+                        const errorText = "Cannot start recording when recording is already resumed";
+                        logger_1.default.error({}, errorText, {}, true);
+                        throw new Error(errorText);
+                    }
+                    recordOptions.siprecServerURL = siprecServerURL;
+                }
+                break;
+            case "pauseCallRecording":
+                if (storedActivity !== "startCallRecording" && process.env.TMP_ENDPOINT_CALL_RECORDING_ENABLE_GLOBALLY !== "true") {
+                    const errorText = "Cannot pause recording when recording is not started";
+                    logger_1.default.error({}, errorText, {}, true);
+                    throw new Error(errorText);
+                }
+                break;
+            case "stopCallRecording":
+                if (storedActivity !== "startCallRecording" && storedActivity !== "resumeCallRecording" && process.env.TMP_ENDPOINT_CALL_RECORDING_ENABLE_GLOBALLY !== "true") {
+                    const errorText = "Cannot stop recording when recording is not started or paused";
+                    logger_1.default.error({}, errorText, {}, true);
+                    throw new Error(errorText);
+                }
+                break;
+            case "resumeCallRecording":
+                if (storedActivity === "resumeCallRecording") {
+                    const warnText = "Cannot resume recording when recording is already resumed";
+                    logger_1.default.warn({}, warnText, {}, true);
+                }
+                else if (storedActivity !== "pauseCallRecording") {
+                    const errorText = "Cannot resume recording when recording is not paused";
+                    logger_1.default.error({}, errorText, {}, true);
+                    throw new Error(errorText);
+                }
+                break;
+            default:
+                throw new Error(`Call Recording - invalid action: ${action}`);
+        }
+        /* Store the action in the context to send proper warnings */
+        api.setSystemContext("vgRecordAction", action);
+        const output = {
+            config: {
+                record: recordOptions
+            }
+        };
+        return output;
+    }
+    handleAudioCodesInput(input, api) {
+        return {};
+    }
+}
+exports.RecordMapper = RecordMapper;
+//# sourceMappingURL=record.mapper.js.map

package/build/shared/charts/descriptors/voice/mappers/sendMetadata.mapper.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendMetadata = void 0;
+const helper_1 = require("../../voicegateway2/utils/helper");
+exports.sendMetadata = {
+    handleInput(endpointType, metadata) {
+        if (!(0, helper_1.isValidJSON)(metadata)) {
+            throw new Error("Invalid JSON in Metadata Field");
+        }
+        if (JSON.stringify(metadata) === '{}') {
+            throw new Error("Nothing is set in Metadata Field");
+        }
+        switch (endpointType) {
+            case "audioCodes":
+                return this.handleAudioCodesInput(metadata);
+            case "voiceGateway2":
+            default:
+                return this.handleVGInput(metadata);
+        }
+    },
+    handleVGInput(metadata) {
+        const voiceGateway2Payload = {
+            "sip:request": {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: "",
+                method: "INFO",
+                actionHook: "/info",
+            },
+        };
+        voiceGateway2Payload["sip:request"].body = JSON.stringify(metadata);
+        return {
+            _voiceGateway2: {
+                json: Object.assign({}, voiceGateway2Payload)
+            }
+        };
+    },
+    handleAudioCodesInput(metadata) {
+        return {
+            _voiceGateway: {
+                json: {
+                    activities: [{
+                            type: "event",
+                            name: "sendMetaData",
+                            value: metadata
+                        }]
+                }
+            }
+        };
+    }
+};
+//# sourceMappingURL=sendMetadata.mapper.js.map

package/build/shared/charts/descriptors/voice/mappers/setSessionConfig.mapper.js

@@ -3,11 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setSessionConfig = exports.vg2PayloadToActivityParams = exports.voiceConfigParamsToVoiceSettings = void 0;
 const strip_nulls_1 = require("../../voicegateway2/utils/strip-nulls");
 const helper_1 = require("../utils/helper");
-const constants_1 = require("../utils/constants");
 function voiceConfigParamsToVoiceSettings(config, api) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     let voiceSettings = {};
-    if (config.bargeInOnSpeech || config.bargeInOnDtmf) {
+    if (typeof config.bargeInOnDtmf === 'boolean' || typeof config.bargeInOnSpeech === 'boolean') {
         voiceSettings.bargeIn = {
             bargeInEnable: false,
             bargeInOnDtmf: (_a = config.bargeInOnDtmf) !== null && _a !== void 0 ? _a : false,
@@ -21,22 +20,65 @@ function voiceConfigParamsToVoiceSettings(config, api) {
         mode: config.sttVadMode,
         voiceMs: config.sttVadVoiceMs,
     };
+    let hints = [];
+    if (config.sttHintsDynamicHints) {
+        if (Array.isArray(config.sttHintsDynamicHints) && ((_c = config.sttHintsDynamicHints) === null || _c === void 0 ? void 0 : _c.length)) {
+            hints = [...config.sttHintsDynamicHints];
+        }
+        else {
+            throw new Error(`Error adding dynamic hints. Context or input is not an array`);
+        }
+    }
+    if (config.sttHints && config.sttHints.length) {
+        hints = [...hints, ...config.sttHints];
+    }
     // stt (recognizer)
     voiceSettings.stt = {
         sttVendor: config.sttVendor,
         sttLanguage: config.sttLanguage,
-        sttHints: config.sttHints,
+        sttHints: hints,
         sttDisablePunctuation: config.sttDisablePunctuation !== undefined &&
             config.sttDisablePunctuation !== null
             ? !config.sttDisablePunctuation
-            : undefined,
+            : undefined
     };
     // tts (synthesizer)
     voiceSettings.tts = {
         ttsVendor: config.ttsVendor,
         ttsLanguage: config.ttsLanguage,
         ttsVoice: config.ttsVoice,
+        azureServiceEndpoint: config.azureTtsDeploymentId,
+        ttsDisableCache: config.ttsDisableCache,
     };
+    if (config.ttsVendor === "microsoft") {
+        if (config.azureTtsDeploymentId) {
+            voiceSettings.tts.azureServiceEndpoint = config.azureTtsDeploymentId;
+        }
+    }
+    if (config.sttVendor === "microsoft") {
+        if (config.recognizeLanguagesAzure) {
+            voiceSettings.stt.altLanguages = [];
+            const languages = [config.sttAzureLang1, config.sttAzureLang2, config.sttAzureLang3];
+            languages.map(language => {
+                var _a, _b;
+                if (language && (language === null || language === void 0 ? void 0 : language.length) > 0) {
+                    (_b = (_a = voiceSettings.stt) === null || _a === void 0 ? void 0 : _a.altLanguages) === null || _b === void 0 ? void 0 : _b.push(language);
+                }
+            });
+        }
+    }
+    if (config.sttVendor === "google") {
+        if (config.recognizeLanguagesGoogle) {
+            voiceSettings.stt.altLanguages = [];
+            const languages = [config.sttGoogleLang1, config.sttGoogleLang2, config.sttGoogleLang3];
+            languages.map(language => {
+                var _a, _b;
+                if (language && (language === null || language === void 0 ? void 0 : language.length) > 0) {
+                    (_b = (_a = voiceSettings.stt) === null || _a === void 0 ? void 0 : _a.altLanguages) === null || _b === void 0 ? void 0 : _b.push(language);
+                }
+            });
+        }
+    }
     // userNoInput
     voiceSettings.userNoInput = {
         userNoInputMode: config.userNoInputMode,
@@ -50,7 +92,7 @@ function voiceConfigParamsToVoiceSettings(config, api) {
         dtmfInterDigitTimeout: config.dtmfInterDigitTimeout,
         dtmfMaxDigits: config.dtmfMaxDigits,
         dtmfMinDigits: config.dtmfMinDigits,
-        dtmfSubmitDigit: (_c = config.dtmfSubmitDigit) === null || _c === void 0 ? void 0 : _c.trim(),
+        dtmfSubmitDigit: (_d = config.dtmfSubmitDigit) === null || _d === void 0 ? void 0 : _d.trim(),
     };
     if (config === null || config === void 0 ? void 0 : config.dtmfEnable) {
         if (voiceSettings.dtmf.dtmfSubmitDigit &&
@@ -85,6 +127,19 @@ function voiceConfigParamsToVoiceSettings(config, api) {
             delete voiceSettings.continuousAsr.asrDigit;
         }
     }
+    // Azure configurations
+    if ((config.sttVendor === "microsoft" && config.azureSttContextId) ||
+        (config.sttVendor === "microsoft" && config.azureTtsDeploymentId)) {
+        voiceSettings.azureConfig = {
+            azureSttContextId: config.azureSttContextId
+                ? config.azureSttContextId.trim()
+                : undefined,
+            azureEnableAudioLogging: config.azureEnableAudioLogging || undefined,
+            azureTtsDeploymentId: config.azureTtsDeploymentId
+                ? config.azureTtsDeploymentId.trim()
+                : undefined,
+        };
+    }
     return (0, strip_nulls_1.stripNulls)(voiceSettings);
 }
 exports.voiceConfigParamsToVoiceSettings = voiceConfigParamsToVoiceSettings;
@@ -102,32 +157,32 @@ function vg2PayloadToActivityParams(payload) {
 exports.vg2PayloadToActivityParams = vg2PayloadToActivityParams;
 exports.setSessionConfig = {
     handleInput(endpointType, voiceSettings) {
-        if (endpointType === constants_1.ENDPOINTS.VOICE_GATEWAY) {
-            return this.handleVGInput(voiceSettings);
-        }
-        else if (endpointType === constants_1.ENDPOINTS.AUDIO_CODES) {
-            return this.handleAudioCodesInput(voiceSettings);
-        }
-        else {
-            return this.handleVGInput(voiceSettings);
+        switch (endpointType) {
+            case "audioCodes":
+                return this.handleAudioCodesInput(voiceSettings);
+            case "voiceGateway2":
+            default:
+                return this.handleVGInput(voiceSettings);
         }
     },
-    handleVGInput(voiceSettings) {
-        var _a;
-        const { bargeIn, continuousAsr, stt, tts, userNoInput, dtmf, vad } = voiceSettings;
+    handleVGInput(voiceSettings, sessionParams, api) {
+        const { bargeIn, continuousAsr, stt, tts, userNoInput, dtmf, vad, azureConfig, } = voiceSettings;
         const user = {};
         const synthesizer = {};
         const recognizer = {};
-        const barge = {};
-        let dtmfParam;
         //verify if there are STT Configs to set
         recognizer.language = (stt === null || stt === void 0 ? void 0 : stt.sttLanguage) || undefined;
         recognizer.hints = (stt === null || stt === void 0 ? void 0 : stt.sttHints) ? stt.sttHints : undefined;
         if (recognizer.hints && recognizer.hints !== undefined) {
             recognizer.hintsBoost = (stt === null || stt === void 0 ? void 0 : stt.sttHintsBoost) || 20;
         }
-        recognizer.vendor = (stt === null || stt === void 0 ? void 0 : stt.sttVendor) ? stt.sttVendor : "default";
+        recognizer.vendor = (stt === null || stt === void 0 ? void 0 : stt.sttVendor) ? stt.sttVendor : undefined;
         recognizer.punctuation = stt === null || stt === void 0 ? void 0 : stt.sttDisablePunctuation;
+        recognizer.azureSttEndpointId = azureConfig === null || azureConfig === void 0 ? void 0 : azureConfig.azureSttContextId;
+        recognizer.audioLogging = azureConfig === null || azureConfig === void 0 ? void 0 : azureConfig.azureEnableAudioLogging;
+        if (recognizer.vendor && (recognizer.vendor === 'microsoft' || recognizer.vendor === 'google')) {
+            recognizer.altLanguages = (stt === null || stt === void 0 ? void 0 : stt.altLanguages) || [];
+        }
         if (vad) {
             recognizer.vad = { enable: vad.enable };
             if (vad.enable) {
@@ -140,18 +195,25 @@ exports.setSessionConfig = {
             synthesizer.vendor = tts.ttsVendor;
             synthesizer.language = tts.ttsLanguage;
             synthesizer.voice = tts.ttsVoice;
+            synthesizer.azureServiceEndpoint = tts.azureServiceEndpoint ? tts.azureServiceEndpoint : "";
         }
         //verify if there are No User Input Configs to set
         if (userNoInput) {
-            user.noInputMode = userNoInput.userNoInputMode;
-            if (userNoInput.userNoInputMode === "speech" &&
-                userNoInput.userNoInputSpeech)
-                user.noInputSpeech = userNoInput.userNoInputSpeech;
-            if (userNoInput.userNoInputMode === "play" && userNoInput.userNoInputUrl)
-                user.noInputUrl = userNoInput.userNoInputUrl;
-            user.noInputRetries = userNoInput.userNoInputRetries || 0;
-            user.noInputTimeout = userNoInput.userNoInputTimeout
-                ? userNoInput.userNoInputTimeout / 1000
+            const { userNoInputRetries, userNoInputMode, userNoInputSpeech, userNoInputTimeout, userNoInputUrl } = userNoInput || {};
+            user.noInputMode = userNoInputMode;
+            if (userNoInputMode === "speech" && userNoInputSpeech)
+                user.noInputSpeech = userNoInputSpeech;
+            if (userNoInputMode === "play" && userNoInputUrl)
+                user.noInputUrl = userNoInputUrl;
+            /* User No Input Retries. min: 0, max: 999*/
+            if (userNoInputRetries < 0 || userNoInputRetries > 999) {
+                user.noInputRetries = 1;
+            }
+            else {
+                user.noInputRetries = userNoInputRetries !== null && userNoInputRetries !== void 0 ? userNoInputRetries : 1;
+            }
+            user.noInputTimeout = userNoInputTimeout
+                ? userNoInputTimeout / 1000
                 : 10;
         }
         // verify if there are Continuous ASR Configs to set
@@ -162,55 +224,69 @@ exports.setSessionConfig = {
                 : undefined;
         }
         // verify if there are Barge In Configs to set
+        let barge = {};
         if (bargeIn) {
-            barge.enable = bargeIn.bargeInEnable;
-            /* Barge in minimum words. min: 1, max: 5, default: 1 */
-            bargeIn.bargeInMinimunWords >= 1 && bargeIn.bargeInMinimunWords <= 5
-                ? barge.minBargeinWordCount = bargeIn.bargeInMinimunWords
-                : barge.minBargeinWordCount = 1;
-            barge.input = [];
-            barge.actionHook = "voice";
-            barge.dtmfBargein = bargeIn.bargeInOnDtmf;
-            if (barge.dtmfBargein) {
-                barge.enable = true;
+            const { bargeInOnSpeech, bargeInOnDtmf, bargeInMinimunWords = 1 } = bargeIn;
+            barge = {
+                enable: bargeInOnSpeech || bargeInOnDtmf,
+                actionHook: "voice",
+                dtmfBargein: bargeInOnDtmf,
+                input: [],
+            };
+            if (bargeInOnDtmf) {
                 barge.input.push("digits");
             }
-            if (bargeIn.bargeInOnSpeech) {
-                barge.enable = true;
+            if (bargeInOnSpeech) {
+                /* Barge in minimum words. min: 1, max: 5, default: 1 */
+                if (bargeInMinimunWords >= 1 && bargeInMinimunWords <= 5) {
+                    barge.minBargeinWordCount = bargeInMinimunWords;
+                }
                 barge.input.push("speech");
             }
         }
-        // verify if there are DTMF Configs to set
+        let enableDTMF;
+        // verify if there are DTMF Configs to set		
         if (dtmf) {
-            dtmfParam = dtmf.dtmfEnable;
-            if (dtmf.dtmfEnable) {
-                barge.enable = (_a = barge.enable) !== null && _a !== void 0 ? _a : false;
-                barge.interDigitTimeout =
-                    dtmf.dtmfInterDigitTimeout && dtmf.dtmfInterDigitTimeout >= 0
-                        ? dtmf.dtmfInterDigitTimeout === 0
-                            ? 0
-                            : dtmf.dtmfInterDigitTimeout / 1000
-                        : undefined;
+            const { dtmfEnable, dtmfInterDigitTimeout = 0, dtmfMaxDigits, dtmfMinDigits, dtmfSubmitDigit } = dtmf;
+            enableDTMF = dtmfEnable;
+            if (dtmfEnable) {
+                barge = Object.assign(Object.assign({}, barge), { maxDigits: 1, minDigits: dtmfMinDigits || 1, finishOnKey: dtmfSubmitDigit });
+                if (typeof dtmfInterDigitTimeout === "number") {
+                    if (dtmfInterDigitTimeout > 0) {
+                        barge.interDigitTimeout = dtmfInterDigitTimeout / 1000;
+                    }
+                }
                 /* Max digits. min: 1, max: - default: 1 */
-                barge.maxDigits = dtmf.dtmfMaxDigits >= 1
-                    ? barge.maxDigits = dtmf.dtmfMaxDigits
-                    : 1;
-                barge.minDigits = dtmf.dtmfMinDigits || 1;
-                barge.finishOnKey = dtmf.dtmfSubmitDigit;
+                if (dtmfMaxDigits >= 1) {
+                    barge.maxDigits = dtmf.dtmfMaxDigits;
+                }
             }
         }
         // Check if there are configs for synthesizer, recognizer and bargeIn
-        const voiceConfig = {
+        let voiceConfig = {
             synthesizer: synthesizer || undefined,
             recognizer: recognizer || undefined,
             bargeIn: barge || undefined,
         };
+        if (voiceConfig.synthesizer && !voiceConfig.synthesizer.azureServiceEndpoint) {
+            voiceConfig.synthesizer.azureServiceEndpoint = "";
+        }
+        if (voiceConfig.recognizer && !voiceConfig.recognizer.azureSttEndpointId) {
+            voiceConfig.recognizer.azureSttEndpointId = "";
+        }
         (0, strip_nulls_1.stripNulls)(voiceConfig);
+        /* As the last step we check the session params JSON for valid properties */
+        if (sessionParams) {
+            voiceConfig.sessionParams = sessionParams;
+        }
         // Check if there are configs for No User Input and DTMF
         const cognigyConfig = {
-            user: user ? user : undefined,
-            dtmf: dtmfParam,
+            user: user || undefined,
+            dtmf: enableDTMF,
         };
+        if (tts && typeof tts.ttsDisableCache === "boolean") {
+            cognigyConfig.disableTtsCache = tts.ttsDisableCache;
+        }
         (0, strip_nulls_1.stripNulls)(cognigyConfig);
         const prePayload = {
             cognigyConfig: Object.keys(cognigyConfig).length
@@ -220,15 +296,21 @@ exports.setSessionConfig = {
                 ? voiceConfig
                 : undefined,
         };
+        if (prePayload.cognigyConfig === undefined) {
+            delete prePayload.cognigyConfig;
+        }
+        if (prePayload.voiceGateway2Config === undefined) {
+            delete prePayload.voiceGateway2Config;
+        }
         const payload = {
             _voiceGateway2: {
-                json: (0, strip_nulls_1.stripNulls)(prePayload),
+                json: Object.assign({}, prePayload),
             },
         };
         return payload;
     },
     handleAudioCodesInput(voiceSettings) {
-        const { bargeIn, continuousAsr, stt, tts, userNoInput, dtmf } = voiceSettings;
+        const { bargeIn, continuousAsr, stt, tts, userNoInput, dtmf, azureConfig } = voiceSettings;
         const sessionParams = {};
         if (stt) {
             sessionParams.sttLanguage = stt.sttLanguage;
@@ -244,6 +326,10 @@ exports.setSessionConfig = {
         if (tts) {
             sessionParams.ttsLanguage = tts.ttsLanguage;
             sessionParams.voiceName = tts.ttsVoice;
+            if (tts.azureServiceEndpoint) {
+                sessionParams.ttsDeploymentId = tts.azureServiceEndpoint;
+            }
+            ;
         }
         if (dtmf) {
             sessionParams.sendDTMF = dtmf.dtmfEnable;
@@ -260,7 +346,9 @@ exports.setSessionConfig = {
         if (bargeIn) {
             sessionParams.bargeIn = bargeIn.bargeInOnSpeech;
             sessionParams.bargeInOnDTMF = bargeIn.bargeInOnDtmf;
-            sessionParams.bargeInMinWordCount = bargeIn.bargeInMinimunWords;
+            if (bargeIn.bargeInMinimunWords >= 1 && bargeIn.bargeInMinimunWords <= 5) {
+                sessionParams.bargeInMinWordCount = bargeIn.bargeInMinimunWords || 1;
+            }
             if (sessionParams.bargeInOnDTMF)
                 sessionParams.sendDTMF = true;
         }
@@ -281,6 +369,13 @@ exports.setSessionConfig = {
                 sessionParams.userNoInputRetries > 0)
                 sessionParams.userNoInputUrl = userNoInput.userNoInputUrl;
         }
+        if (azureConfig === null || azureConfig === void 0 ? void 0 : azureConfig.azureSttContextId) {
+            sessionParams.sttContextId = azureConfig.azureSttContextId;
+            if (azureConfig.azureEnableAudioLogging) {
+                sessionParams.azureEnableAudioLogging =
+                    azureConfig.azureEnableAudioLogging;
+            }
+        }
         const activities = {
             type: "event",
             name: "config",