@onereach/step-voice 4.0.37 → 4.0.39

package/dst/Custom Voice Input.d.ts

@@ -0,0 +1,35 @@
+import VoiceStep, { TODO, VoiceEvent } from './voice';
+interface INPUT {
+    textType: string;
+    asr: TODO;
+    tts: TODO;
+    audio: TODO[];
+    choices: TODO[];
+    prompts: TODO[];
+    sensitiveData: {
+        muteStep: boolean;
+        muteUser: boolean;
+        muteBot: boolean;
+    };
+    noReplyDelay: number;
+    promptsTriggers: TODO[];
+    usePromptsTriggers: boolean;
+    recognitionModel?: string;
+    resultInterpretation?: string;
+    phraseList: Array<{
+        phrase: string;
+    }>;
+}
+interface EVENT extends VoiceEvent {
+    callRecording?: TODO;
+    exitId?: string;
+    digit?: string;
+    digits?: string;
+    phrases?: TODO[];
+    tags?: string[];
+    out?: string;
+}
+export default class CustomVoiceInput extends VoiceStep<INPUT, {}, EVENT> {
+    runStep(): Promise<void>;
+}
+export {};

package/dst/Custom Voice Input.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const voice_1 = tslib_1.__importDefault(require("./voice"));
+const getPhrasesForSpeechRec = (choices) => {
+    const texts = lodash_1.default.flatMap(choices, (choice) => choice.options.map((opt) => opt.text));
+    return texts;
+};
+const getAsrSettings = (settings, choices, recognitionModel) => {
+    if (settings.engine === 'google' || settings.engine === 'google_beta') {
+        return {
+            ...settings,
+            config: {
+                speechContexts: [
+                    {
+                        phrases: getPhrasesForSpeechRec(choices)
+                    }
+                ],
+                recognitionModel
+            }
+        };
+    }
+    return settings;
+};
+const isRepromptTrigger = (recogResult, promptsTriggers) => {
+    const phrases = recogResult.map((r) => {
+        return r.lexical;
+    });
+    const triggers = promptsTriggers.flatMap((trigger) => {
+        if (lodash_1.default.isEmpty(trigger.grammar)) {
+            return trigger.text.replace(/`/g, '');
+        }
+        else {
+            return trigger.grammar.value.map((v) => {
+                return v.replace(/`/g, '');
+            });
+        }
+    });
+    return !lodash_1.default.isEmpty(phrases.filter((e) => triggers.includes(e)));
+};
+class CustomVoiceInput extends voice_1.default {
+    async runStep() {
+        const channel = await this.fetchData();
+        const { textType, asr, tts, sensitiveData, noReplyDelay, usePromptsTriggers, recognitionModel } = this.data;
+        const exitExists = (exitId) => {
+            return lodash_1.default.some(choices, (choice) => choice.exitId === exitId);
+        };
+        const mainLeg = {
+            exitId: '5886d1ee-db6d-45ca-a2ce-d586862c65ff',
+            dtmf: null,
+            grxml: '',
+            text: `.+`,
+            grammar: {},
+        };
+        const choices = this.buildChoices({ choices: [...this.data.choices, mainLeg] });
+        const ttsSettings = tts.getSettings(channel.tts);
+        const asrSettings = getAsrSettings(asr.getSettings(channel.asr), choices, recognitionModel);
+        const repromptsList = this.buildReprompts({ prompts: this.data.prompts });
+        const speechSections = this.buildSections({ sections: this.data.audio, textType, ttsSettings });
+        const grammar = {
+            id: this.currentStepId,
+            choices,
+            asr: asrSettings
+        };
+        const command = {
+            name: 'double-asr',
+            params: {
+                grammar,
+                sections: [],
+                resultInterpretation: this.data.resultInterpretation,
+                tokenPhrases: this.data.phraseList.map(item => item.phrase)
+            }
+        };
+        // There's a specific need to do so. There might be ${variable} section
+        this.triggers.once(`in/voice/${channel.id}/event`, async (event) => {
+            // await thisStep.refreshCallback(this, conversation, channel); -- ???
+            if (channel.recordCall && sensitiveData?.muteStep) {
+                await this.sendCommands(channel, [{
+                        name: 'resume-record-session',
+                        params: {
+                            muteUser: sensitiveData.muteUser,
+                            muteBot: sensitiveData.muteBot
+                        }
+                    }]);
+            }
+            const reportingSettingsKey = this.rptsStarted ? 'transcriptRepromptResponse' : 'transcriptResponse';
+            switch (event.params.type) {
+                // digit recognition removed
+                case 'recognition': {
+                    const params = event.params;
+                    const exitId = params.exitId;
+                    const phrases = params.phrases;
+                    if (lodash_1.default.isEmpty(phrases)) {
+                        return this.exitStep('unrecognized', {});
+                    }
+                    const voiceProcessResult = lodash_1.default.chain(phrases)
+                        .map((p) => p.lexical)
+                        .join(' | ')
+                        .value();
+                    // On bargeIn, we should stop playback
+                    if (exitExists(exitId)) {
+                        await this.transcript(channel, {
+                            message: lodash_1.default.replace(this.getExitStepLabel(exitId) ?? '', /^(\d+\. )?(~ )?/, ''),
+                            voiceProcessResult,
+                            reportingSettingsKey,
+                            action: 'Call Recognition',
+                            actionFromBot: false
+                        });
+                        // There might be hooks after this step which we will try to avoid
+                        return this.exitStep(exitId, this.exitChoiceData('voice', params));
+                    }
+                    else if (this.rptsHasMore({ repromptsList }) &&
+                        (usePromptsTriggers ? isRepromptTrigger(phrases, this.data.promptsTriggers) : true)) {
+                        await this.transcript(channel, {
+                            message: 'Unrecognized',
+                            voiceProcessResult,
+                            reportingSettingsKey,
+                            action: 'Call Recognition',
+                            actionFromBot: false
+                        });
+                        await this.rptsSend(channel, {
+                            command,
+                            repromptsList,
+                            noReplyDelay,
+                            speechSections,
+                            textType,
+                            ttsSettings
+                        });
+                        return this.exitFlow();
+                    }
+                    // There's no more reprompts, should move on to unrecognized direction
+                    await this.transcript(channel, {
+                        message: 'Not Recognized',
+                        voiceProcessResult,
+                        reportingSettingsKey,
+                        action: 'Call Recognition',
+                        actionFromBot: false
+                    });
+                    // We might end up in same session
+                    return this.exitStep('unrecognized', this.exitChoiceData('voice', params));
+                }
+                case 'timeout': {
+                    if (this.rptsHasMore({ repromptsList })) {
+                        await this.transcript(channel, {
+                            message: 'No Reply',
+                            reportingSettingsKey,
+                            action: 'Call Prompt',
+                            actionFromBot: false
+                        });
+                        await this.rptsSend(channel, {
+                            command,
+                            repromptsList,
+                            noReplyDelay,
+                            speechSections,
+                            textType,
+                            ttsSettings
+                        });
+                        return this.exitFlow();
+                    }
+                    await this.transcript(channel, {
+                        message: 'Not Replied',
+                        reportingSettingsKey,
+                        action: 'Call Prompt',
+                        actionFromBot: false
+                    });
+                    // We might end up in same session
+                    return this.exitStep('no reply', {});
+                }
+                case 'hangup': {
+                    await this.handleHangup(channel);
+                    return await this.waitConvEnd();
+                }
+                // case 'cancel': {
+                //   return this.data.handleCancel === true && this.exitStep('cancel')
+                // }
+                case 'error':
+                    return this.throwError(event.params.error);
+                default:
+                    return this.exitFlow();
+            }
+        });
+        this.triggers.otherwise(async () => {
+            await this.transcript(channel, {
+                sections: speechSections,
+                reprompt: {
+                    maxAttempts: repromptsList.length,
+                    attempt: 0
+                },
+                reportingSettingsKey: 'transcriptPrompt',
+                action: 'Call Prompt',
+                actionFromBot: true
+            });
+            command.params.sections = speechSections;
+            command.params.timeout = this.rptsTimeout({ noReplyDelay, repromptsList });
+            await this.sendCommands(channel, [
+                ...channel.recordCall && sensitiveData?.muteStep
+                    ? [{
+                            name: 'stop-record-session',
+                            params: {
+                                muteUser: sensitiveData.muteUser,
+                                muteBot: sensitiveData.muteBot
+                            }
+                        }]
+                    : [],
+                command
+            ]);
+            return this.exitFlow();
+        });
+    }
+}
+exports.default = CustomVoiceInput;
+// --------------------------------------------------------------------

package/dst/Transfer.d.ts

@@ -9,7 +9,7 @@ interface INPUT {
     }>;
     refer: boolean;
     gatewaySettigsMode?: string;
-    identifierForInheritance?: string;
+    from?: string;
     sipHost?: string;
     sipUser?: string;
     sipPassword?: string;

package/dst/Transfer.js

@@ -48,7 +48,7 @@ class Transfer extends voice_1.default {
             return this.exitFlow();
         });
         this.triggers.otherwise(async () => {
-            const { phoneNumber, sessionTimeout, destination, sipHeaders = [], sipHost, sipUser, sipPassword, refer, gatewaySettigsMode, identifierForInheritance } = this.data;
+            const { phoneNumber, sessionTimeout, destination, sipHeaders = [], sipHost, sipUser, sipPassword, refer, gatewaySettigsMode, from } = this.data;
             const destinationIsSip = (/^sip:/i).test(destination);
             const destinationIsUser = (/^user:/i).test(destination);
             const callerID = phoneNumber;
@@ -58,7 +58,7 @@ class Transfer extends voice_1.default {
             const command = {
                 name: destinationIsSip ? (refer ? 'refer' : 'bridge_sip') : (destinationIsUser ? 'bridge_user' : 'bridge'),
                 params: {
-                    botNumber: inheritGatewaySetting ? identifierForInheritance : channel.botNumber,
+                    botNumber: inheritGatewaySetting ? from : channel.botNumber,
                     transferFrom: callerID,
                     transferTo: destination,
                     headers,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onereach/step-voice",
-  "version": "4.0.37",
+  "version": "4.0.39",
   "author": "Roman Zolotarov <roman.zolotarov@onereach.com>",
   "contributors": [
     "Roman Zolotarov",