@onereach/step-voice 4.0.13 → 4.0.16

package/dst/Global Command.d.ts

@@ -25,7 +25,7 @@ interface EVENT extends VoiceEvent {
     tags?: string[];
     out?: string;
 }
-export default class GlobalCommand extends VoiceStep<INPUT, OUTPUT, EVENT> {
+export default class GlobalCommand extends VoiceStep<Partial<INPUT>, OUTPUT, EVENT> {
     get isGlobal(): boolean;
     get autoCancel(): boolean | undefined;
     runStep(): Promise<void>;

package/dst/Global Command.js

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable @typescript-eslint/strict-boolean-expressions, @typescript-eslint/explicit-function-return-type */
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const lodash_1 = tslib_1.__importDefault(require("lodash"));

package/dst/Initiate Call.d.ts

@@ -1,8 +1,27 @@
-export default class InitiateCall extends VoiceStep<any, any, import("./voice").VoiceEvent> {
-    constructor(thread: import("@onereach/flow-sdk/dst/types").IThread, stepData: import("@onereach/flow-sdk/dst/types").IStepData<any>);
-    get conversation(): string;
+import VoiceStep, { CallStartEvent, TODO } from './voice';
+interface INPUT {
+    channelId?: string;
+    sessionTimeout?: number;
+    asr: TODO;
+    tts: TODO;
+    from: string;
+    endUserNumber: string;
+    sipHost?: string;
+    sipUser?: string;
+    sipPassword?: string;
+    timeout?: number;
+    headers?: Array<{
+        name: string;
+        value: string;
+    }>;
+    enableSpoofCallerId?: boolean;
+    spoofCallerId?: string;
+    isAMD?: boolean;
+}
+export default class InitiateCall extends VoiceStep<INPUT, TODO, CallStartEvent> {
+    get conversation(): string | import("@onereach/flow-sdk/dst/types").IMergeField;
     get autoCancel(): undefined;
     runStep(): Promise<void>;
     waitForCall(): Promise<void>;
 }
-import VoiceStep from "./voice";
+export {};

package/dst/Initiate Call.js

@@ -1,22 +1,25 @@
 "use strict";
+/* eslint-disable @typescript-eslint/strict-boolean-expressions, @typescript-eslint/explicit-function-return-type */
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const voice_1 = tslib_1.__importDefault(require("./voice"));
-const _ = require('lodash');
-const timestring = require('timestring');
-const uuid = require('uuid');
-const defaultSessionTimeout = 5 * 60 * 1000;
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const timestring_1 = tslib_1.__importDefault(require("timestring"));
+const uuid_1 = tslib_1.__importDefault(require("uuid"));
+const defaultSessionTimeoutMin = 5;
 class InitiateCall extends voice_1.default {
     get conversation() {
-        return this.step.dataOut?.name ?? 'conversation';
+        if (this.step.dataOut == null)
+            throw new Error('missing conversation');
+        return this.step.dataOut;
     }
     get autoCancel() {
         return undefined;
     }
     async runStep() {
-        const { channelId = uuid.v4() } = this.data;
+        const { channelId = uuid_1.default.v4() } = this.data;
         if (!this.session.key) {
-            const sessionTimeoutMs = timestring(`${this.data.sessionTimeout} min`, 'ms') || defaultSessionTimeout;
+            const sessionTimeoutMs = (0, timestring_1.default)(`${this.data.sessionTimeout ?? defaultSessionTimeoutMin} min`, 'ms');
             await this.session.start({
                 key: channelId,
                 timeout: sessionTimeoutMs,
@@ -27,7 +30,8 @@ class InitiateCall extends voice_1.default {
                 }
             });
         }
-        await this.startConversation({ id: channelId, type: 'voicer' }, { events: [] });
+        const convData = { id: channelId, type: 'voicer' };
+        await this.startConversation(convData, { events: {} });
         this.gotoState('waitForCall');
     }
     async waitForCall() {
@@ -44,18 +48,18 @@ class InitiateCall extends voice_1.default {
                             }
                         };
                     });
-                    await this.startConversation(event.params.channel, { events: [] });
+                    await this.startConversation(event.params.channel, { events: {} });
                     this.log.warn({ channel: event.params.channel, conv: this.conversation, data: this.get(this.conversation) }, 'Confirming that the OB call can be started');
                     return this.exitFlow();
                 }
                 case 'call': {
                     const channel = {
-                        botNumber: event.params.channel.to,
-                        endUserNumber,
                         headers: event.params.headers,
+                        ...event.params.channel,
                         asr: asr.getSettings(),
                         tts: tts.getVoice(),
-                        ...event.params.channel
+                        botNumber: event.params.channel.to ?? 'unknown',
+                        endUserNumber
                     };
                     delete channel.from;
                     delete channel.to;
@@ -88,7 +92,7 @@ class InitiateCall extends voice_1.default {
                     return this.exitStep('success');
                 }
                 case 'error': {
-                    const error = _.get(event, 'params.error.originateStatus');
+                    const error = lodash_1.default.get(event, 'params.error.originateStatus');
                     const errorChannel = {
                         botNumber,
                         endUserNumber
@@ -108,9 +112,10 @@ class InitiateCall extends voice_1.default {
                             return this.exitStep('no answer', errorChannel);
                     }
                     await this.transcript(errorChannel, { action: 'Call Error' });
+                    const errorParams = event.params.error;
                     return this.throwError({
-                        name: event.params.error.name,
-                        message: `${event.params.error.date}: ${event.params.error.originateStatus}`
+                        name: event.params.error?.name ?? 'VoiceError',
+                        message: `${errorParams.date}: ${errorParams.originateStatus}`
                     });
                 }
                 default:
@@ -119,8 +124,8 @@ class InitiateCall extends voice_1.default {
         });
         this.triggers.otherwise(async () => {
             await this.triggers.flush();
-            const originateTimeout = timestring(`${timeout || 30} sec`, 'ms'); // timeout or 30 seconds
-            const customHeaders = _.reduce(headers, (memo, header) => {
+            const originateTimeout = (0, timestring_1.default)(`${timeout ?? 30} sec`, 'ms'); // timeout or 30 seconds
+            const customHeaders = lodash_1.default.reduce(headers, (memo, header) => {
                 memo[header.name] = `${header.value}`;
                 return memo;
             }, {});

package/dst/Say Message.d.ts

@@ -12,7 +12,7 @@ interface INPUT {
     };
     interSpeechTimeout: number;
 }
-export default class SayMessage extends VoiceStep<INPUT> {
+export default class SayMessage extends VoiceStep<Partial<INPUT>> {
     runStep(): Promise<void>;
 }
 export {};

package/dst/Say Message.js

@@ -1,11 +1,12 @@
 "use strict";
+/* eslint-disable @typescript-eslint/strict-boolean-expressions, @typescript-eslint/explicit-function-return-type */
 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"));
 class SayMessage extends voice_1.default {
     async runStep() {
-        const { audio, textType, tts, sensitiveData, interSpeechTimeout } = this.data;
+        const { audio, textType, tts, sensitiveData, interSpeechTimeout = 0 } = this.data;
         const channel = await this.fetchData();
         this.triggers.once(`in/voice/${channel.id}/event`, async (event) => {
             if (channel.recordCall && sensitiveData?.muteStep) {

package/dst/Wait For Call.d.ts

@@ -1,8 +1,8 @@
-export default class WaitForCall extends VoiceStep<any, any, import("./voice").VoiceEvent> {
-    constructor(thread: import("@onereach/flow-sdk/dst/types").IThread, stepData: import("@onereach/flow-sdk/dst/types").IStepData<any>);
-    get conversation(): string | undefined;
+import VoiceStep, { CallStartEvent, TODO } from './voice';
+import { ITypedEvent } from '@onereach/flow-sdk/dst/types';
+export default class WaitForCall extends VoiceStep<TODO, TODO, TODO> {
+    get conversation(): string | import("@onereach/flow-sdk/dst/types").IMergeField;
     get autoCancel(): boolean;
     runStep(): Promise<void>;
-    onCall(event: any): Promise<unknown>;
+    onCall(event: ITypedEvent<CallStartEvent>): Promise<unknown>;
 }
-import VoiceStep from "./voice";

package/dst/Wait For Call.js

@@ -1,32 +1,35 @@
 "use strict";
+/* eslint-disable @typescript-eslint/strict-boolean-expressions, @typescript-eslint/explicit-function-return-type */
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const voice_1 = tslib_1.__importDefault(require("./voice"));
-const _ = require('lodash');
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
 const defaultSessionTimeout = 5 * 60 * 1000;
 class WaitForCall extends voice_1.default {
     get conversation() {
-        return this.step.dataOut.name;
+        if (this.step.dataOut == null)
+            throw new Error('missing conversation');
+        return this.step.dataOut;
     }
     get autoCancel() {
         return false;
     }
     async runStep() {
         const selectedNumbers = this.data.selectedNumbers;
-        _.forEach(selectedNumbers, number => {
-            this.triggers.on(`in/voice/${number.value}/call`, event => this.onCall(event));
+        lodash_1.default.forEach(selectedNumbers, number => {
+            this.triggers.on(`in/voice/${number.value}/call`, async (event) => await this.onCall(event));
         });
     }
     async onCall(event) {
         const { autoHangup, asr, tts, endOfInputTimeout } = this.data;
         const channel = {
-            autoHangup,
-            botNumber: event.params.channel.to,
-            endUserNumber: event.params.channel.from,
             headers: event.params.headers,
+            ...event.params.channel,
+            autoHangup,
             asr: asr.getSettings(),
             tts: tts.getVoice(),
-            ...event.params.channel
+            botNumber: event.params.channel.to ?? 'unknown',
+            endUserNumber: event.params.channel?.from ?? 'unknown'
         };
         delete channel.from;
         delete channel.to;

package/dst/step.d.ts

@@ -0,0 +1,49 @@
+import Step from '@onereach/flow-sdk/dst/step';
+import { IThreadId, IEvent, IStepResult, IMergeField, IMergeFieldKey } from '@onereach/flow-sdk/dst/types';
+import { IConversationData, IConversation, IConversationStep } from '@onereach/step-conversation/dst/types';
+export interface ConvStepDataIn {
+    conversation?: IMergeFieldKey | IMergeField;
+    conversationThread?: string;
+}
+export default class ConvStep<TData = unknown, TIn = unknown, TOut = unknown, TParams = any> extends Step<TIn & ConvStepDataIn, TOut, TParams> {
+    convDataCache?: TData & IConversationData;
+    get conversation(): IMergeFieldKey | IMergeField;
+    /** id of the thread where conversation data is stored */
+    get dataThreadId(): IThreadId;
+    get autoCancel(): boolean | undefined;
+    get isGlobal(): boolean;
+    get useQueue(): boolean;
+    fetchData(): Promise<TData & IConversationData>;
+    updateData(): Promise<void>;
+    hasConversation(): Promise<boolean>;
+    runBefore(): Promise<void>;
+    runAfter(): Promise<void>;
+    hasActiveGlobal(): Promise<boolean>;
+    setTriggerType(): Promise<void>;
+    waitForConversation(): Promise<void>;
+    onSkipEvent(): Promise<void>;
+    cancel(): Promise<void>;
+    onCancel(): Promise<void>;
+    waitCancelEnd(): Promise<void>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    sendEventToStep({ toGlobal, toStep, action, event }: {
+        action?: string;
+        event?: IEvent;
+        toStep?: IConversationStep;
+        toGlobal?: boolean;
+    }): Promise<IStepResult | undefined>;
+    activeStep(isGlobal?: boolean): Promise<IConversationStep | undefined>;
+    /** @returns true if current conv is active */
+    pushConvStep(): Promise<boolean>;
+    /** @returns true if current conv was active */
+    popConvStep(): Promise<boolean>;
+    startConversation(data: TData, { autoCancel, events }: {
+        autoCancel?: boolean;
+        events: Record<string, {}>;
+        thread?: IThreadId;
+    }): Promise<void>;
+    _fetchData(): Promise<(TData & IConversationData) | undefined>;
+    _getConversation(): Promise<IConversation>;
+    _clearCache(): void;
+}

package/dst/step.js

@@ -0,0 +1,264 @@
+"use strict";
+/* eslint-disable @typescript-eslint/strict-boolean-expressions */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const step_1 = tslib_1.__importDefault(require("@onereach/flow-sdk/dst/step"));
+class ConvStep extends step_1.default {
+    get conversation() {
+        if (this.data.conversation == null)
+            throw new Error('missing conversation');
+        return this.data.conversation;
+    }
+    /** id of the thread where conversation data is stored */
+    get dataThreadId() {
+        const dataThreadId = this.state.thread ?? this.data.conversationThread;
+        return dataThreadId || this.thread.id;
+    }
+    get autoCancel() {
+        return undefined;
+    }
+    get isGlobal() {
+        return false;
+    }
+    get useQueue() {
+        return true;
+    }
+    async fetchData() {
+        const data = await this._fetchData();
+        if (data?._conv == null)
+            throw new Error(`missing conversation data in state ${this.state.name}`);
+        return data;
+    }
+    async updateData() {
+        if (this.convDataCache == null)
+            throw new Error(`missing conversation cache in state ${this.state.name}`);
+        // console.log('UPDATE', this.conversation, this.thread.id, this.step.label, this.convDataCache?._conv.que)
+        const convDataThread = this.process.getSafeThread(this.dataThreadId);
+        await convDataThread.set(this.conversation, this.convDataCache);
+    }
+    async hasConversation() {
+        return (await this._fetchData())?._conv != null;
+    }
+    async runBefore() {
+        this.log.debug('conv.runBefore', { state: this.state, conv: this.conversation });
+        await super.runBefore();
+        // ensure cache is reset between step runs, just in case
+        this._clearCache();
+        this.triggers.local('_conv');
+        if (!await this.hasConversation())
+            return;
+        if (this.state.direct)
+            return;
+        if (this.event.action === 'cancel') {
+            this.state.name = 'onCancel';
+            return;
+        }
+        if (this.useQueue && !await this.pushConvStep()) {
+            return await this.waitForConversation();
+        }
+        if (this.event.action == null && this.event.processed !== true && this.convDataCache?._conv?.trg?.[this.event.name] != null) {
+            if (this.isGlobal)
+                return;
+            const hasGlobal = await this.sendEventToStep({ event: { ...this.event, action: 'global' }, toGlobal: true }); // redirect to global (1)
+            this.log.debug('conv.sendEventToStep toGlobal', { hasGlobal });
+            if (hasGlobal != null) {
+                this.state.prevSkipName = this.state.name;
+                this.state.name = 'onSkipEvent';
+                return;
+            }
+        }
+        if (this.isGlobal && this.event.action === 'global') {
+            return; // it was redirected from (1)
+        }
+        if (!this.isGlobal && (this.convDataCache?._conv?.glb?.length ?? 0) > 0) {
+            this.triggers.config({ params: { type: 'local' } });
+        }
+    }
+    async runAfter() {
+        if (!await this.hasConversation())
+            return await super.runAfter();
+        if (this.thread.hasControlAction()) {
+            if (await this.popConvStep()) {
+                await this.sendEventToStep({ toGlobal: this.isGlobal, action: 'activate' });
+            }
+        }
+        if (this.isGlobal && this.event.processed !== true) {
+            await this.sendEventToStep({ toGlobal: false, event: { ...this.event, processed: undefined, action: 'local' } });
+        }
+        await super.runAfter();
+    }
+    async hasActiveGlobal() {
+        const globalLength = (await this._getConversation())?.glb?.length ?? 0;
+        return globalLength > 0;
+    }
+    async setTriggerType() {
+        if (!this.isGlobal && !await this.hasActiveGlobal()) {
+            this.triggers.config({ params: { type: 'local' } });
+        }
+    }
+    async waitForConversation() {
+        if (this.state.name !== 'waitForConversation') {
+            this.log.debug(this.state, 'conv.begin waitForConversation');
+            this.state.prevWaitName = this.state.name;
+            this.state.name = 'waitForConversation';
+        }
+        else if (this.event.name === '_conv') {
+            this.log.debug(this.state, 'conv.end waitForConversation');
+            this.gotoState({ ...this.state, name: this.state.prevWaitName, prevWaitName: undefined });
+        }
+        else {
+            this.log.debug(this.state, 'conv.skip waitForConversation');
+        }
+    }
+    async onSkipEvent() {
+        this.log.debug('onSkipEvent');
+        this.state.name = this.state.prevSkipName;
+        delete this.state.prevSkipName;
+    }
+    async cancel() {
+        if (this.isGlobal) {
+            this.log.debug('conv.cannot cancel global');
+            return;
+        }
+        const conv = await this._getConversation();
+        const activeStep = await this.activeStep(false);
+        if (activeStep != null) {
+            this.log.debug('conv.cancel', activeStep);
+            conv.lcl.splice(0);
+            await this.updateData();
+            await this.sendEventToStep({ toGlobal: false, action: 'cancel', toStep: activeStep });
+        }
+        else {
+            this.log.debug('conv.nothing to cancel');
+        }
+    }
+    async onCancel() {
+        if (this.getExitStepId('cancel')) {
+            this.log.debug('conv.cancel exit');
+            this.exitStep('cancel');
+        }
+        else {
+            const conversationThread = this.state.thread ?? this.thread.id;
+            if (conversationThread === this.thread.id) {
+                this.log.debug('conv.cancel wait for end', this.conversation);
+                this.gotoState({ ...this.state, name: 'waitCancelEnd', direct: true });
+            }
+            else {
+                this.log.debug('conv.cancel end', this.conversation);
+                this.end();
+            }
+        }
+    }
+    async waitCancelEnd() {
+        this.exitFlow();
+    }
+    async pause() {
+        const conv = await this._getConversation();
+        const activeStep = await this.activeStep(false);
+        if (activeStep != null) {
+            this.log.debug('conv.pause', activeStep);
+            conv.stk.push(conv.lcl.splice(0)); // save que to stk
+            await this.sendEventToStep({ toGlobal: false, action: 'pause', toStep: activeStep });
+        }
+        else {
+            this.log.debug('conv.nothing to pause');
+        }
+    }
+    async resume() {
+        const conv = await this._getConversation();
+        if (conv.stk.length > 0) {
+            conv.lcl.unshift(...(conv.stk.pop() ?? [])); // restore que from stk
+            await this.sendEventToStep({ toGlobal: false, action: 'resume' });
+        }
+        else {
+            this.log.debug('conv.nothing to resume');
+        }
+    }
+    async sendEventToStep({ toGlobal, toStep, action, event = { name: '_conv', action } }) {
+        toStep || (toStep = await this.activeStep(toGlobal));
+        if (toStep != null) {
+            const target = { type: 'session', name: toStep.key, id: toStep.thread };
+            return await this.thread.eventManager.emit(event, { invocationType: 'async', target });
+        }
+        return undefined;
+    }
+    async activeStep(isGlobal = this.isGlobal) {
+        const conv = await this._getConversation();
+        return isGlobal ? conv.glb[conv.glb.length - 1] : conv.lcl[0];
+    }
+    /** @returns true if current conv is active */
+    async pushConvStep() {
+        const conv = await this._getConversation();
+        const sessionKey = this.session.key;
+        if (sessionKey == null)
+            throw new Error('session is required');
+        const que = this.isGlobal ? conv.glb : conv.lcl;
+        const queIndex = que.findIndex(stp => stp.key === sessionKey && this.thread.id === stp.thread);
+        if (queIndex < 0) {
+            if (que.length > 0 && !this.isGlobal && (this.autoCancel ?? conv.acl ?? false))
+                await this.cancel();
+            que.push({ key: sessionKey, thread: this.thread.id });
+            await this.updateData();
+            return this.isGlobal ? true : que.length === 1;
+        }
+        return queIndex === (this.isGlobal ? que.length - 1 : 0);
+    }
+    /** @returns true if current conv was active */
+    async popConvStep() {
+        const conv = await this._getConversation();
+        const sessionKey = this.session.key;
+        if (sessionKey == null)
+            throw new Error('session is required');
+        const que = this.isGlobal ? conv.glb : conv.lcl;
+        const queIndex = que.findIndex(stp => stp.key === sessionKey && this.thread.id === stp.thread);
+        if (queIndex >= 0) {
+            // console.log('SPLICE1', this.thread.id, this.step.label, que)
+            que.splice(queIndex, 1);
+            await this.updateData();
+            return this.isGlobal ? queIndex === que.length : queIndex === 0;
+        }
+        let updated = false;
+        conv.stk.forEach((steps, stepsIdx) => {
+            const stpIdx = steps.findIndex(stp => stp.key === sessionKey && this.thread.id === stp.thread);
+            if (stpIdx >= 0) {
+                if (steps.length > 1)
+                    steps.splice(stpIdx, 1);
+                else
+                    conv.stk.splice(stepsIdx, 1);
+                updated = true;
+            }
+        });
+        if (updated)
+            await this.updateData();
+        return false;
+    }
+    async startConversation(data, { autoCancel = false, events }) {
+        this.convDataCache = {
+            ...data,
+            _conv: {
+                acl: (autoCancel ? 1 : undefined),
+                trg: events,
+                glb: [],
+                stk: [],
+                lcl: []
+            }
+        };
+        await this.updateData();
+        // this.state.thread = this.dataThreadId
+    }
+    async _fetchData() {
+        if (this.convDataCache != null)
+            return this.convDataCache;
+        const convDataThread = this.process.getSafeThread(this.dataThreadId);
+        this.convDataCache = await convDataThread.get(this.conversation);
+        // console.log('FETCH', this.conversation, this.thread.id, this.step.label, this.convDataCache?._conv.que)
+        return this.convDataCache;
+    }
+    async _getConversation() {
+        return (await this.fetchData())._conv;
+    }
+    _clearCache() {
+        this.convDataCache = undefined;
+    }
+}
+exports.default = ConvStep;

package/dst/voice.d.ts

@@ -1,5 +1,5 @@
 import { ICallback, IVoiceReporterTranscriptEventArgs, IPromtpSection } from '@onereach/flow-sdk/dst/types';
-import ConvStep from '@onereach/step-conversation/dst/step';
+import ConvStep from './step';
 import BasicError from '@onereach/flow-sdk/dst/errors/base';
 export declare type TODO = any;
 export interface IVoiceChannel {
@@ -16,20 +16,25 @@ export interface IVoiceChannel {
     asr?: TODO;
     tts?: TODO;
     sessionEndedBy?: string;
+    to?: string;
+    from?: string;
+    headers?: Record<string, string>;
 }
-export declare type EventType = 'hangup' | 'error' | 'cancel' | 'avm-detected' | 'recognition' | 'digit' | 'digits' | 'conference-start' | 'conference-end' | 'playback' | 'timeout' | 'record' | 'bridge' | 'bridge/ended';
+export declare type EventType = 'hangup' | 'error' | 'cancel' | 'avm-detected' | 'recognition' | 'digit' | 'digits' | 'conference-start' | 'conference-end' | 'playback' | 'timeout' | 'record' | 'bridge' | 'bridge/ended' | 'is_flow_ready' | 'call';
 export declare class VoiceStepError extends BasicError {
 }
 export interface VoiceEvent {
     type: EventType;
     error?: Error;
 }
+export interface CallStartEvent extends VoiceEvent {
+    channel: IVoiceChannel;
+    headers?: Record<string, string>;
+}
 export default class VoiceStep<TIn = unknown, TOut = unknown, TParams = VoiceEvent> extends ConvStep<IVoiceChannel, TIn & {
     handleCancel?: boolean;
 }, TOut, TParams> {
     get autoCancel(): boolean | undefined;
-    onCancel(): Promise<void>;
-    waitForEnd(): Promise<void>;
     sendCommands({ id, type, callback }: IVoiceChannel, commands: TODO[]): Promise<unknown>;
     extractSectionMessages(sections: IPromtpSection[]): string;
     extractSectionFiles(sections: IPromtpSection[]): Array<{

package/dst/voice.js

@@ -5,7 +5,8 @@ exports.VoiceStepError = void 0;
 const tslib_1 = require("tslib");
 const lodash_1 = tslib_1.__importDefault(require("lodash"));
 const uuid_1 = require("uuid");
-const step_1 = tslib_1.__importDefault(require("@onereach/step-conversation/dst/step"));
+// TODO: !!!!! import ConvStep from '@onereach/step-conversation/dst/step' !!!!!
+const step_1 = tslib_1.__importDefault(require("./step"));
 const base_1 = tslib_1.__importDefault(require("@onereach/flow-sdk/dst/errors/base"));
 class VoiceStepError extends base_1.default {
 }
@@ -15,17 +16,6 @@ class VoiceStep extends step_1.default {
     get autoCancel() {
         return true;
     }
-    async onCancel() {
-        if (this.data.handleCancel === true) {
-            this.exitStep('cancel');
-        }
-        else {
-            this.gotoState('waitForEnd');
-        }
-    }
-    async waitForEnd() {
-        this.exitFlow();
-    }
     async sendCommands({ id, type, callback }, commands) {
         if (lodash_1.default.isEmpty(commands))
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onereach/step-voice",
-  "version": "4.0.13",
+  "version": "4.0.16",
   "author": "Roman Zolotarov <roman.zolotarov@onereach.com>",
   "contributors": [
     "Roman Zolotarov",
@@ -13,12 +13,12 @@
     "npm": ">= 6.0.0"
   },
   "dependencies": {
-    "@onereach/step-conversation": "^1.0.33",
+    "@onereach/step-conversation": "^1.0.40",
     "lodash": "^4.17.21",
     "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "@onereach/flow-sdk": "^3.0.14",
+    "@onereach/flow-sdk": "^3.1.3",
     "@swc/cli": "^0.1.57",
     "@swc/core": "^1.2.197",
     "@swc/jest": "^0.2.21",
@@ -26,7 +26,7 @@
     "@types/lodash": "^4.14.182",
     "@types/timestring": "^6.0.2",
     "@types/uuid": "^8.3.4",
-    "aws-sdk": "^2.1149.0",
+    "aws-sdk": "^2.1151.0",
     "babel-runtime": "^6.26.0",
     "docdash": "^1.2.0",
     "husky": "^8.0.1",