@onereach/step-voice 5.0.9-fixsubflow.1 → 5.0.9-fixsubflow.3

package/dst/Cancel.js

@@ -4,12 +4,12 @@ const tslib_1 = require("tslib");
 const voice_1 = tslib_1.__importDefault(require("./voice"));
 class VoiceCancel extends voice_1.default {
     async runStep() {
-        const conv = await this.getConversation();
-        if (conv.lcl.length <= 1) {
-            this.log.debug('nothing to cancel');
-            this.exitStep('next');
-            return;
-        }
+        // const conv = await this.getConversation()
+        // if (conv.lcl.length <= 1) {
+        //   this.log.debug('nothing to cancel')
+        //   this.exitStep('next')
+        //   return
+        // }
         const call = await this.fetchData();
         this.triggers.once(`in/voice/${call.id}/event`, async (event) => {
             switch (event.params.type) {
@@ -19,7 +19,7 @@ class VoiceCancel extends voice_1.default {
                 case 'error':
                     return this.throwError(event.params.error);
                 case 'cancel': {
-                    await this.popConvStep(); // pop current command (cancel)
+                    // await this.popConvStep() // pop current command (cancel)
                     await this.cancel(); // cancel previous command
                     return this.exitStep('next');
                 }

package/dst/Global Command.d.ts

@@ -31,7 +31,7 @@ export default class GlobalCommand extends VoiceStep<Partial<INPUT>, OUTPUT, EVE
     get useQueue(): boolean;
     runStep(): Promise<void>;
     initGrammar(): Promise<void>;
-    globThread(): Promise<void>;
+    _worker(): Promise<void>;
     hangup(call: IVoiceCall): Promise<unknown>;
     exitThread(event: ITypedEvent<EVENT>, type: string, stepExit: string): Promise<void>;
     onAwake(): Promise<void>;

package/dst/Global Command.js

@@ -7,28 +7,12 @@ const nanoid_1 = require("nanoid");
 const voice_1 = tslib_1.__importDefault(require("./voice"));
 class GlobalCommand extends voice_1.default {
     get isGlobal() {
-        return this.thread.id === this.globalThreadId;
+        return true;
     }
     get useQueue() {
-        return this.isGlobal;
+        return this.isWorker;
     }
     async runStep() {
-        const globThread = this.process.newThread(this.globalThreadId, thread => {
-            thread.state = {
-                name: 'globThread',
-                step: this.step.id,
-                thread: this.dataThreadId
-            };
-        });
-        if (globThread.isNewThread) {
-            globThread.activate();
-            await globThread.run();
-        }
-        else {
-            globThread.state.step = this.step.id;
-        }
-        // refresh cache after global thread was started
-        this._clearCache();
         await this.initGrammar();
         this.exitStep('no commands');
     }
@@ -62,23 +46,26 @@ class GlobalCommand extends voice_1.default {
             }
         ]);
     }
-    async globThread() {
+    async _worker() {
         const call = await this.fetchData();
         if (call.vv >= 1 && lodash_1.default.isFunction(this.triggers.hook)) {
-            this.triggers.hook({ name: 'ending', thread: 'main' }, async () => {
+            this.triggers.hook({ name: 'waitEnd', thread: 'main', sync: true }, async () => {
                 this.thread.background = call._conv.glb.length > 1;
-                this.log.debug('gc set background', { bg: this.thread.background, len: call._conv.glb.length });
+                if (this.thread.background)
+                    this.end();
             });
             this.triggers.hook({ name: 'end', thread: 'main' }, async () => {
                 this.log.debug('gc terminate', { bg: this.thread.background });
-                if (await this.popConvStep()) {
-                    await this.sendEventToStep({ toGlobal: this.isGlobal, action: 'onAwake' });
-                }
-                this.end();
+                // if (await this.popConvStep()) {
+                //   await this.sendEventToStep({ toWorker: this.isWorker, action: 'onAwake' })
+                // }
+                await this.sendCommands(call, [{ name: 'grammar', params: {} }]);
+                if (!this.thread.ending)
+                    this.end();
             });
             // TODO remove this hack that prevents this.triggers.once execution below
             // currently it skips logic to override triggers (is there better way to do it?)
-            if (this.event.name.startsWith('@end'))
+            if (this.event.name.startsWith('@'))
                 return;
         }
         this.triggers.once(`in/voice/${call.id}/event`, async (event) => {
@@ -86,7 +73,7 @@ class GlobalCommand extends voice_1.default {
             switch (event.params.type) {
                 case 'hangup': {
                     await this.hangup(call);
-                    await this.popConvStep();
+                    // await this.popConvStep()
                     await this.notifyConvEnd();
                     return this.end();
                 }
@@ -137,10 +124,10 @@ class GlobalCommand extends voice_1.default {
                     return {};
                 }
                 case 'error': {
-                    const localHandler = await this.sendEventToStep({ toGlobal: false, event: { ...this.event, processed: undefined, action: 'local' } });
-                    if (!localHandler) {
-                        this.throwError(event.params.error);
-                    }
+                    // const localHandler = await this.sendEventToStep({ toWorker: false, event: { ...this.event, processed: undefined, action: 'lcl' } })
+                    // if (!localHandler) {
+                    //   this.throwError(event.params.error)
+                    // }
                     this.event.processed = true;
                     break;
                 }
@@ -223,7 +210,7 @@ class GlobalCommand extends voice_1.default {
     async onAwake() {
         await super.onAwake();
         await this.initGrammar();
-        await this.globThread();
+        await this.worker();
         this.triggers.refreshAll();
     }
     exitToThread() {

package/dst/Initiate Call.js

@@ -31,9 +31,9 @@ class InitiateCall extends voice_1.default {
                 }
             });
         }
-        const convData = { id: callId, type: 'voicer', vv: 0 };
+        const convData = { id: callId, type: 'voicer', vv: 0 }; // vv - voicer version
         await this.startConversation(convData);
-        await this.pushConvStep();
+        // await this.pushConvStep()
         this.gotoState('waitForCall');
     }
     async onAwake() {
@@ -66,7 +66,7 @@ class InitiateCall extends voice_1.default {
                     return this.exitFlow();
                 }
                 case 'call': {
-                    const call = {
+                    const newCall = {
                         headers: event.params.headers,
                         ...event.params.channel,
                         asr: asr.getSettings(),
@@ -74,15 +74,17 @@ class InitiateCall extends voice_1.default {
                         botNumber: event.params.channel.to ?? 'unknown',
                         endUserNumber
                     };
-                    delete call.from;
-                    delete call.to;
-                    await this.startConversation(call);
-                    await this.transcript(call, {
+                    delete newCall.from;
+                    delete newCall.to;
+                    newCall._conv = call._conv;
+                    await this.startConversation(newCall);
+                    // await this.popConvStep()
+                    await this.transcript(newCall, {
                         action: 'Call Start',
                         reportingSettingsKey: 'transcript',
                         actionFromBot: true
                     });
-                    await this.sendCommands(call, [
+                    await this.sendCommands(newCall, [
                         ...isAMD
                             ? [{
                                     name: 'start-avmd',
@@ -102,6 +104,11 @@ class InitiateCall extends voice_1.default {
                     ]);
                     return this.exitStep('success');
                 }
+                case 'hangup': {
+                    await this.handleHangup(call);
+                    this.end();
+                    break;
+                }
                 case 'error': {
                     const error = lodash_1.default.get(event, 'params.error.originateStatus');
                     const errorCall = {

package/dst/Say Message.js

@@ -18,10 +18,9 @@ class SayMessage extends voice_1.default {
                     return this.exitStep('next');
                 case 'error':
                     return this.throwError(event.params.error);
-                //
-                // case 'cancel': {
-                //   return this.data.handleCancel === true && this.exitStep('cancel')
-                // }
+                case 'cancel': {
+                    return this.data.handleCancel === true && this.exitStep('cancel');
+                }
                 default:
                     return this.exitFlow();
             }

package/dst/Send DTMF.d.ts

@@ -1,4 +1,4 @@
-import VoiceStep from "./voice";
+import VoiceStep from './voice';
 interface INPUT {
     dtmf: string;
     tonesDuration: string;

package/dst/Send DTMF.js

@@ -7,23 +7,23 @@ const schema = joi_1.default.object().keys({
     dtmf: joi_1.default
         .string()
         .required()
-        .replace(/\s+/, "")
-        .pattern(/^[0-9A-DwW*#]+$/, "symbols")
+        .replace(/\s+/, '')
+        .pattern(/^[0-9A-DwW*#]+$/, 'symbols')
         .messages({
-        "string.pattern.symbols": "{{#label}} should only contain symbols like: 0-9, *, #, A-D, W, w",
+        'string.pattern.symbols': '{{#label}} should only contain symbols like: 0-9, *, #, A-D, W, w'
     }),
     tonesDuration: joi_1.default.number().required().min(200).max(5000).messages({
-        "number.min": "{{#label}} should be between 200 and 5000 milliseconds",
-        "number.max": "{{#label}} should be between 200 and 5000 milliseconds",
+        'number.min': '{{#label}} should be between 200 and 5000 milliseconds',
+        'number.max': '{{#label}} should be between 200 and 5000 milliseconds'
     }),
     beforeDelay: joi_1.default.number().required().min(0).max(5000).messages({
-        "number.min": "{{#label}} should be between 0 and 5000 milliseconds",
-        "number.max": "{{#label}} should be between 0 and 5000 milliseconds",
+        'number.min': '{{#label}} should be between 0 and 5000 milliseconds',
+        'number.max': '{{#label}} should be between 0 and 5000 milliseconds'
     }),
     afterDelay: joi_1.default.number().required().min(0).max(5000).messages({
-        "number.min": "{{#label}} should be between 0 and 5000 milliseconds",
-        "number.max": "{{#label}} should be between 0 and 5000 milliseconds",
-    }),
+        'number.min': '{{#label}} should be between 0 and 5000 milliseconds',
+        'number.max': '{{#label}} should be between 0 and 5000 milliseconds'
+    })
 });
 class SendDTMF extends voice_1.default {
     async runStep() {
@@ -33,18 +33,18 @@ class SendDTMF extends voice_1.default {
             dtmf,
             tonesDuration,
             beforeDelay,
-            afterDelay,
+            afterDelay
         });
         if (validationError != null)
             throw new Error(validationError.message);
         const command = {
-            name: "send-dtmf",
+            name: 'send-dtmf',
             params: {
                 dtmf,
                 tonesDuration: +tonesDuration,
                 beforeDelay: +beforeDelay,
-                afterDelay: +afterDelay,
-            },
+                afterDelay: +afterDelay
+            }
         };
         this.triggers.once(`in/voice/${call.id}/event`, async (event) => {
             // if (channel.callback.id)
@@ -53,11 +53,11 @@ class SendDTMF extends voice_1.default {
             //     "callback"
             //   );
             switch (event.params.type) {
-                case "hangup":
+                case 'hangup':
                     return this.end();
-                case "dtmf-sent":
-                    return this.exitStep("next");
-                case "error":
+                case 'dtmf-sent':
+                    return this.exitStep('next');
+                case 'error':
                     return this.throwError(event.params.error);
                 default:
                     return this.exitFlow();
@@ -65,11 +65,11 @@ class SendDTMF extends voice_1.default {
         });
         this.triggers.otherwise(async () => {
             await this.transcript(call, {
-                reportingSettingsKey: "transcript",
-                action: "Send DTMF",
+                reportingSettingsKey: 'transcript',
+                action: 'Send DTMF',
                 actionFromBot: true,
                 keyPress: dtmf,
-                message: dtmf,
+                message: dtmf
             });
             await this.sendCommands(call, [command]);
             return this.exitFlow();

package/dst/step.d.ts

@@ -1,36 +1,49 @@
 import Step from '@onereach/flow-sdk/dst/step';
-import { IThreadId, IEvent, IStepResult, IMergeField, ISessionId } from '@onereach/flow-sdk/dst/types';
-import { IConversationStep } from '@onereach/step-conversation/dst/types';
+import { IThreadId, IMergeField } from '@onereach/flow-sdk/dst/types';
 export interface ConvStepDataIn {
     conversation?: string | IMergeField;
     conversationThread?: IThreadId;
 }
-interface IConversation {
-    glb: IConversationStep[];
+export interface IConversation {
     lcl: IConversationStep[];
-    sid?: ISessionId;
+    glb: IConversationStep[];
 }
-interface IConversationData {
+export interface IConversationData {
     _conv: IConversation;
 }
-export default class ConvStep<TData = unknown, TIn = unknown, TOut = unknown, TParams = any> extends Step<TIn & ConvStepDataIn, TOut, TParams> {
+export declare const enum ConvThreadType {
+    lcl = "lcl",
+    glb = "glb",
+    wrk = "wrk"
+}
+interface IConversationStep {
+    key: string;
+    trd: string;
+    typ?: string;
+    name?: string;
+    label?: string;
+    step?: string;
+}
+export default abstract class ConvStep<TData extends IConversationData, TIn = unknown, TOut = unknown, TParams = any> extends Step<TIn & ConvStepDataIn, TOut, TParams> {
     private convDataCache?;
-    get cache(): TData & IConversationData | undefined;
+    abstract _worker(data: IConversationData): Promise<void>;
+    get cache(): TData | undefined;
     get conversation(): string | IMergeField;
     get conversationId(): string;
-    get globalThreadId(): string;
+    get workerThreadId(): string;
     /** id of the thread where conversation data is stored */
     get dataThreadId(): IThreadId;
     get isGlobal(): boolean;
+    get threadType(): ConvThreadType;
+    get isWorker(): boolean;
     get useQueue(): boolean;
-    fetchData(): Promise<TData & IConversationData>;
+    fetchData(): Promise<TData>;
     getConversation(): Promise<IConversation>;
     updateData(): Promise<void>;
     hasConversation(): Promise<boolean>;
+    protected worker(): Promise<void>;
     runBefore(): Promise<void>;
-    runHandle(): Promise<unknown>;
     runAfter(): Promise<void>;
-    hasActiveGlobal(): Promise<boolean>;
     waitForConversation(): Promise<void>;
     protected onSkipEvent(): Promise<void>;
     cancel(): Promise<void>;
@@ -47,21 +60,12 @@ export default class ConvStep<TData = unknown, TIn = unknown, TOut = unknown, TP
     onConvEnd(): Promise<void>;
     pause(): Promise<void>;
     resume(): Promise<void>;
-    protected 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 */
-    protected pushConvStep(): Promise<boolean>;
     /** @returns true if current conv was active */
-    protected popConvStep(popStep?: IConversationStep): Promise<boolean>;
     startConversation(data: TData, { thread }?: {
         thread?: IThreadId;
     }): Promise<void>;
-    protected _fetchCache(): Promise<(TData & IConversationData) | undefined>;
+    protected _fetchCache(): Promise<(TData) | undefined>;
     protected _clearCache(): void;
     protected _refreshCache(): Promise<void>;
 }

package/dst/step.js

@@ -25,7 +25,7 @@ class ConvStep extends step_1.default {
             return convOrName;
         throw new Error(`invalid conversation ${JSON.stringify(conv)}`);
     }
-    get globalThreadId() {
+    get workerThreadId() {
         return `G:${this.conversationId}`;
     }
     /** id of the thread where conversation data is stored */
@@ -36,6 +36,14 @@ class ConvStep extends step_1.default {
     get isGlobal() {
         return false;
     }
+    get threadType() {
+        return this.thread.id === this.workerThreadId
+            ? (this.isGlobal ? "glb" /* ConvThreadType.glb */ : "wrk" /* ConvThreadType.wrk */)
+            : "lcl" /* ConvThreadType.lcl */;
+    }
+    get isWorker() {
+        return this.threadType !== "lcl" /* ConvThreadType.lcl */;
+    }
     get useQueue() {
         return true;
     }
@@ -58,13 +66,18 @@ class ConvStep extends step_1.default {
     async hasConversation() {
         return (await this._fetchCache())?._conv != null;
     }
+    async worker() {
+        this.triggers.local('_conv');
+        if (this.cache == null)
+            return;
+        await this._worker(this.cache);
+    }
     async runBefore() {
         await super.runBefore();
         if (this.thread.ending)
             return;
         // ensure cache is reset between step runs, just in case
         this._clearCache();
-        this.triggers.local('_conv');
         if (!await this.hasConversation())
             return;
         this.log.debug('conv.runBefore', { state: this.state, conv: this.convDataCache?._conv });
@@ -76,36 +89,69 @@ class ConvStep extends step_1.default {
             this.state.name = this.event.action;
             return;
         }
-        if (this.useQueue && !await this.pushConvStep()) {
-            return await this.waitForConversation();
-        }
-    }
-    async runHandle() {
-        const sid = this.cache?._conv.sid;
-        if (sid != null && sid !== this.session.sessionId) {
-            this.triggers.refreshAll();
-        }
-        return await super.runHandle();
-    }
-    async runAfter() {
-        if (this.thread.ending)
+        console.log('BEFORE', {
+            event: this.event,
+            state: this.state,
+            name: this.constructor.name,
+            thread: this.thread.id,
+            ...this.cache?._conv
+        });
+        // if (this.useQueue && !await this.pushConvStep()) {
+        //   return await this.waitForConversation()
+        // }
+        if (this.cache == null)
             return;
-        if (!await this.hasConversation())
-            return await super.runAfter();
-        if (this.thread.hasControlAction()) {
-            // await this.popConvStep()
-            if (await this.popConvStep()) {
-                await this.sendEventToStep({ toGlobal: this.isGlobal, action: 'onAwake' });
+        // const glb = this.cache._conv.glb
+        // if (!this.isGlobal && glb.length > 0 && glb[glb.length - 1].typ !== ConvThreadType.wrk) return
+        if (!this.isGlobal)
+            return;
+        if (this.thread.id !== this.workerThreadId) {
+            const worker = this.process.newThread(this.workerThreadId, thread => {
+                thread.state = {
+                    name: 'worker',
+                    step: this.step.id,
+                    thread: this.dataThreadId
+                };
+            });
+            if (worker.isNewThread === true || worker.state.step !== this.step.id) {
+                worker.state.step = this.step.id;
+                worker.activate();
+                await worker.run();
+                await this._refreshCache();
             }
         }
-        if (this.isGlobal && !this.event.processed) {
-            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;
+    // public async runHandle (): Promise<unknown> {
+    //   if (this.thread.ending || this.state.name === 'onConvEnd') {
+    //     return await super.runHandle()
+    //   }
+    //   // const sid = this.cache?._conv.sid
+    //   // if (sid != null && sid !== this.session.sessionId) {
+    //   //   this.triggers.refreshAll()
+    //   // }
+    //   return await super.runHandle()
+    // }
+    async runAfter() {
+        console.log('AFTER', {
+            name: this.constructor.name,
+            thread: this.thread.id,
+            ...this.cache?._conv
+        });
+        // if (this.thread.ending || this.state.name === 'onConvEnd') {
+        //   return await super.runAfter()
+        // }
+        // if (!await this.hasConversation()) return await super.runAfter()
+        // if (this.thread.hasControlAction()) {
+        //   // await this.popConvStep()
+        //   if (await this.popConvStep()) {
+        //     // TODO: this seems not to be necessary now or not?
+        //     await this.sendEventToStep({ toGlobal: this.isGlobal, action: 'onAwake' })
+        //   }
+        // }
+        // if (this.isGlobal && !this.event.processed) {
+        //   await this.sendEventToStep({ toGlobal: false, event: { ...this.event, processed: undefined, action: 'lcl' } })
+        // }
+        await super.runAfter();
     }
     // public async setLocalTriggers (): Promise<void> {
     //   if (!this.isGlobal && await this.hasActiveGlobal()) {
@@ -132,15 +178,15 @@ class ConvStep extends step_1.default {
         delete this.state.prevSkipName;
     }
     async cancel() {
-        if (this.isGlobal) {
+        if (this.isWorker) {
             this.log.debug('conv.cannot cancel global');
-            return;
+            // return
         }
-        const activeStep = await this.activeStep();
-        await this.sendEventToStep({ event: { name: '_conv', action: 'onCancel', params: { byStep: this.step.label } }, toStep: activeStep });
+        // const activeStep = await this.activeStep(this.isWorker)
+        // await this.sendEventToStep({ event: { name: '_conv', action: 'onCancel', params: { byStep: this.step.label } }, toStep: activeStep })
     }
     async onCancel() {
-        await this.popConvStep();
+        // await this.popConvStep()
         if (this.getExitStepId('cancel')) {
             this.log.debug('conv.cancel exit');
             this.exitStep('cancel');
@@ -156,7 +202,7 @@ class ConvStep extends step_1.default {
         this.state.name = this.state.resumeState;
         this.state.resumeState = undefined;
         const conv = await this.getConversation();
-        if (this.isGlobal && conv.glb.length === 1) {
+        if (this.isWorker && conv.glb.length === 1) {
             this.log.debug('make global thread foreground');
             this.thread.background = false;
         }
@@ -172,20 +218,21 @@ class ConvStep extends step_1.default {
     async notifyConvEnd({ onlyLocal } = {}) {
         const conv = await this.getConversation();
         const lcl = conv.lcl.splice(0);
-        const glb = onlyLocal ? [] : conv.glb.splice(0);
-        if (lcl.length > 0 || glb.length > 0) {
+        const wrk = onlyLocal ? [] : conv.glb.splice(0);
+        if (lcl.length > 0 || wrk.length > 0) {
             await this.updateData();
-            for (const step of lcl) {
-                await this.sendEventToStep({ toStep: step, action: 'onConvEnd' });
-            }
-            for (const step of glb) {
-                await this.sendEventToStep({ toStep: step, action: 'onConvEnd' });
-            }
+            // for (const step of lcl) {
+            //   await this.sendEventToStep({ toStep: step, action: 'onConvEnd' })
+            // }
+            // for (const step of wrk) {
+            //   await this.sendEventToStep({ toStep: step, action: 'onConvEnd' })
+            // }
         }
     }
     async waitConvEnd() {
-        const conversationThread = this.state.thread ?? this.thread.id;
-        if (!this.isGlobal && conversationThread === this.thread.id && this.thread.id !== 'main') {
+        const workerThread = this.process.getThread(this.workerThreadId);
+        const workerData = await workerThread?.currentStep.resolveDataIn();
+        if (!this.isGlobal && this.thread.id !== 'main' && this.thread.id === workerData?.conversationThread) {
             this.log.debug('conv.wait for end', this.conversation);
             this.gotoState({ ...this.state, name: 'waitGlobEnd', direct: true });
         }
@@ -195,7 +242,7 @@ class ConvStep extends step_1.default {
         }
     }
     async waitGlobEnd() {
-        const gcThreadId = this.globalThreadId;
+        const gcThreadId = this.workerThreadId;
         // wait for glob thread end (if exists)
         this.triggers.hook({ name: 'end', thread: gcThreadId }, async () => await this.onConvEnd());
         if (!this.process.getThread(gcThreadId))
@@ -218,7 +265,7 @@ class ConvStep extends step_1.default {
     }
     async resume() {
         // const conv = await this._getConversation()
-        // if (conv.stk.length > 0) {
+        // if (conv.stk.length> 0) {
         //   conv.lcl.unshift(...(conv.stk.pop() ?? [])) // restore que from stk
         //   await this.updateData()
         //   await this.sendEventToStep({ toGlobal: false, action: 'onResume' })
@@ -226,66 +273,96 @@ class ConvStep extends step_1.default {
         //   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[conv.lcl.length - 1];
-    }
+    // protected async sendEventToStep ({
+    //   toGlobal = false,
+    //   toStep,
+    //   action,
+    //   event = { name: '_conv', action }
+    // }: {
+    //   action?: string
+    //   event?: IEvent
+    //   toStep?: IConversationStep
+    //   toGlobal?: boolean
+    // }): Promise<IStepResult | undefined> {
+    //   toStep ||= await this.activeStep(toGlobal)
+    //   if (toStep != null) {
+    //     const target = { type: 'session' as any, name: toStep.key, id: toStep.trd }
+    //     return await this.thread.eventManager.emit(
+    //       event,
+    //       { invocationType: 'async', target }
+    //     )
+    //   }
+    //   return undefined
+    // }
+    // async activeStep (toGlobal: boolean): Promise<IConversationStep | undefined> {
+    //   const conv = await this.getConversation()
+    //   const que = toGlobal ? conv.glb : conv.lcl
+    //   if (que == null) return
+    //   const lastItem = que[que.length - 1]
+    //   if (toGlobal && lastItem?.typ === ConvThreadType.wrk) return undefined
+    //   return que[que.length - 1]
+    // }
     /** @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) {
-            await this.sendEventToStep({ toGlobal: this.isGlobal, event: { name: '_conv', action: 'onPause', params: { byStep: this.step.label } } });
-            que.push({ key: sessionKey, thread: this.thread.id, name: this.constructor.name, label: this.label, step: this.id });
-            await this.updateData();
-            return true;
-        }
-        return queIndex === que.length - 1;
-    }
+    // protected async pushConvStep (): Promise<boolean> {
+    //   const conv = await this.getConversation()
+    //   const sessionKey = this.session.key
+    //   if (sessionKey == null) throw new Error('session is required')
+    //   const que = this.isWorker ? conv.glb : conv.lcl
+    //   const lastItem = que[que.length - 1]
+    //   const lastItemType = lastItem?.typ
+    //   if (lastItemType === ConvThreadType.wrk) {
+    //     console.log('POP', lastItem)
+    //     que.pop() // remove last item, since it's temporary
+    //     // TODO triggers.refreshAll!
+    //   }
+    //   const queIndex = que.findIndex(stp => stp.key === sessionKey && this.thread.id === stp.trd)
+    //   if (queIndex < 0) {
+    //     if (que.length > 0) {
+    //       await this.sendEventToStep({ toGlobal: this.isGlobal, event: { name: '_conv', action: 'onPause', params: { byStep: this.step.label } } })
+    //     }
+    //     const type = this.threadType === ConvThreadType.wrk ? this.threadType : undefined
+    //     que.push({ key: sessionKey, trd: this.thread.id, typ: type, name: this.constructor.name, label: this.label, step: this.id })
+    //     console.log('PUSH', que[que.length - 1])
+    //     await this.updateData()
+    //     return true
+    //   }
+    //   // refresh data on step change
+    //   que[queIndex].name = this.constructor.name
+    //   que[queIndex].label = this.label
+    //   que[queIndex].step = this.id
+    //   return queIndex === que.length - 1
+    // }
     /** @returns true if current conv was active */
-    async popConvStep(popStep) {
-        const conv = await this.getConversation();
-        const sessionKey = this.session.key;
-        if (sessionKey == null)
-            throw new Error('session is required');
-        popStep || (popStep = { key: sessionKey, thread: this.thread.id });
-        const que = this.isGlobal ? conv.glb : conv.lcl;
-        const queIndex = que.findIndex(stp => stp.key === popStep?.key && stp.thread === popStep.thread);
-        if (queIndex >= 0) {
-            // console.log('SPLICE1', this.thread.id, this.step.label, que)
-            que.splice(queIndex, 1);
-            conv.sid = this.session.sessionId;
-            await this.updateData();
-            return queIndex === que.length;
-        }
-        // 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;
-    }
+    // protected async popConvStep (popStep?: IConversationStep): Promise<boolean> {
+    //   const conv = await this.getConversation()
+    //   const sessionKey = this.session.key
+    //   if (sessionKey == null) throw new Error('session is required')
+    //   popStep ||= { key: sessionKey, trd: this.thread.id }
+    //   const que = this.isWorker ? conv.glb : conv.lcl
+    //   const queIndex = que.findIndex(stp => stp.key === popStep?.key && stp.trd === popStep.trd)
+    //   if (queIndex >= 0) {
+    //     // console.log('SPLICE1', this.thread.id, this.step.label, que)
+    //     que.splice(queIndex, 1)
+    //     // conv.sid = this.session.sessionId
+    //     await this.updateData()
+    //     return queIndex === que.length
+    //   }
+    //   // 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, { thread: _thread } = {}) {
         this.convDataCache = {
             ...data,
-            _conv: {
+            _conv: data._conv ?? {
                 glb: [],
                 lcl: []
             }

package/dst/voice.d.ts

@@ -1,5 +1,5 @@
 import { ICallback, IVoiceReporterTranscriptEventArgs, IPromtpSection } from '@onereach/flow-sdk/dst/types';
-import ConvStep from './step';
+import ConvStep, { IConversationData } from './step';
 import BasicError from '@onereach/flow-sdk/dst/errors/base';
 export type TODO = any;
 export interface SensitiveData {
@@ -7,7 +7,7 @@ export interface SensitiveData {
     muteUser: boolean;
     muteBot: boolean;
 }
-export interface IVoiceCall {
+export interface IVoiceCall extends IConversationData {
     vv: number;
     id: string;
     ended: boolean;
@@ -44,6 +44,7 @@ export interface CallStartEvent extends VoiceEvent {
 export default class VoiceStep<TIn = unknown, TOut = unknown, TParams extends VoiceEvent = VoiceEvent> extends ConvStep<IVoiceCall, TIn & {
     handleCancel?: boolean;
 }, TOut, TParams> {
+    _worker(call: IVoiceCall): Promise<void>;
     runBefore(): Promise<void>;
     sendCommands({ id, type, callback }: IVoiceCall, commands: TODO[]): Promise<void>;
     handleHeartbeat(call: IVoiceCall): Promise<void>;

package/dst/voice.js

@@ -13,17 +13,27 @@ class VoiceStepError extends base_1.default {
 exports.VoiceStepError = VoiceStepError;
 class VoiceStep extends step_1.default {
     // static Error = VoiceStepError
+    async _worker(call) {
+        this.triggers.once(`in/voice/${call.id}/event`, async (event) => {
+            console.log('EVENT', {
+                name: this.constructor.name,
+                thread: this.thread.id,
+                event
+            });
+        });
+    }
     async runBefore() {
         await super.runBefore();
         if (this.cache != null) {
-            if (!this.event.processed && !this.isGlobal && this.event.params.global && this.event.action == null) {
-                const hasGlobal = await this.sendEventToStep({ event: { ...this.event, action: 'global' }, toGlobal: true }); // redirect to global (1)
-                if (hasGlobal != null) {
-                    this.log.debug('conv.sendEventToStep toGlobal', { hasGlobal });
-                    this.state.prevSkipName = this.state.name;
-                    this.state.name = 'onSkipEvent';
-                }
-            }
+            // if (!this.event.processed && this.event.action == null) {
+            //   const toWorker = this.event.params.global
+            //   const hasHandler = await this.sendEventToStep({ event: { ...this.event, action: toWorker ? 'wrk' : 'lcl' }, toWorker }) // redirect to global (1)
+            //   if (hasHandler != null) {
+            //     this.log.debug('hasWorker', { hasGlobal: hasHandler })
+            //     this.state.prevSkipName = this.state.name
+            //     this.state.name = 'onSkipEvent'
+            //   }
+            // }
             await this.handleHeartbeat(this.cache);
         }
     }
@@ -35,10 +45,11 @@ class VoiceStep extends step_1.default {
             name: `out/voice/${type}`,
             params: {
                 id,
-                cancel: this.isGlobal ? undefined : true,
-                async: this.isGlobal ? true : undefined,
+                cancel: this.isWorker ? undefined : true,
+                async: this.isWorker ? true : undefined,
                 hbs: 99,
-                commands
+                commands,
+                step: { key: this.session.key, trd: this.isGlobal ? this.workerThreadId : this.thread.id } // response should be sent to this session
             },
             reporting: this.session.getSessionRef()
         }, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onereach/step-voice",
-  "version": "5.0.9-fixsubflow.1",
+  "version": "5.0.9-fixsubflow.3",
   "author": "Roman Zolotarov <roman.zolotarov@onereach.com>",
   "contributors": [
     "Roman Zolotarov",
@@ -19,7 +19,7 @@
     "uuid": "^9.0.0"
   },
   "devDependencies": {
-    "@onereach/flow-sdk": "^3.2.12",
+    "@onereach/flow-sdk": "^3.2.16",
     "@onereach/step-voice": "./test",
     "@swc/cli": "^0.1.62",
     "@swc/core": "^1.3.57",