@onereach/step-voice 7.0.2-VOIC1438.11 → 7.0.2-VOIC1438.13

package/dst/MeetOps.d.ts

@@ -1,4 +1,4 @@
-import VoiceStep, { CallStartEvent, IVoiceCall } from './voice';
+import VoiceStep, { CallStartEvent, IVoiceCall, TODO } from './voice';
 interface MeetOpsInput {
     callId?: string;
     sessionTimeout?: number | string;
@@ -17,13 +17,23 @@ interface MeetOpsInput {
     enableSpoofCallerId?: boolean;
     spoofCallerId?: string;
     isAMD?: boolean;
+    asr: TODO;
+    meetOps: {
+        dtmfPin: string;
+        durationMs: number;
+        idleTimeoutMs: number;
+    };
 }
 interface MeetOpsOutput {
 }
 export default class MeetOps extends VoiceStep<MeetOpsInput, MeetOpsOutput, CallStartEvent> {
     get conversation(): string | import("@onereach/flow-sdk/dst/types").IMergeField;
     runStep(): Promise<void>;
+    onAwake(): Promise<void>;
     waitForJoin(): Promise<void>;
+    private onHangup;
+    private onError;
+    private onCall;
     originate(call: IVoiceCall): Promise<void>;
 }
 export {};

package/dst/MeetOps.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const uuid = tslib_1.__importStar(require("uuid"));
+const timestring_1 = tslib_1.__importDefault(require("timestring"));
 const voice_1 = tslib_1.__importDefault(require("./voice"));
 class MeetOps extends voice_1.default {
     get conversation() {
@@ -14,27 +15,160 @@ class MeetOps extends voice_1.default {
         if (!this.session.key) {
             await this.session.start({
                 key: callId,
-                timeout: 10000,
+                timeout: (0, timestring_1.default)('120 min'),
                 reporting: {
                     settingsKey: 'session',
                     startedBy: 'Bot',
-                    sessionType: 'Phone'
-                }
+                    sessionType: 'Phone',
+                },
             });
         }
         const convData = { id: callId, type: 'voicer', vv: 0 };
         await this.startConversation(convData);
         this.gotoState('waitForJoin');
     }
+    async onAwake() {
+        const { handleCancel } = this.data;
+        await super.onAwake();
+        const call = await this.fetchData();
+        if (!call.ended)
+            throw new Error('unpexpected awake');
+        if (handleCancel !== true)
+            throw new Error('hangup cancel');
+        this.exitStep('cancel');
+    }
     async waitForJoin() {
         const call = await this.fetchData();
-        // this.triggers.once(`in/voice/${call.id}/event`, async (event) => {
-        // })
+        this.triggers.once(`in/voice/${call.id}/event`, async (event) => {
+            this.log.debug('call event type:', event.params.type);
+            this.log.debug('call event:', event);
+            switch (event.params.type) {
+                case 'is_flow_ready':
+                    return this.exitFlow({ is_ready: true });
+                case 'call':
+                    return await this.onCall(event, call);
+                case 'hangup':
+                    return await this.onHangup(event, call);
+                case 'error':
+                    return await this.onError(event);
+                default:
+                    return this.exitFlow();
+            }
+        });
         this.triggers.otherwise(async () => {
             await this.triggers.flush();
             await this.originate(call);
         });
     }
+    async onHangup(event, call) {
+        const { handleCancel } = this.data;
+        await this.handleHangup(call);
+        if (handleCancel && event.params.error?.name === 'CancelError') {
+            return this.exitStep('cancel');
+        }
+        return this.throwError(event.params.error ?? {
+            name: 'HangupError',
+            message: 'unpexpected hangup during init call'
+        });
+    }
+    async onError(event) {
+        const { from: botNumber, endUserNumber } = this.data;
+        const error = event.params.error;
+        const errorStatus = error?.originateStatus ?? 'UNKNOWN';
+        const errorCall = {
+            botNumber,
+            endUserNumber
+        };
+        switch (errorStatus) {
+            case 'USER_BUSY':
+                await this.transcript(errorCall, {
+                    action: 'Call Busy',
+                    actionFromBot: true
+                });
+                await this.updateData();
+                return this.exitStep('busy', errorCall);
+            case 'NO_ANSWER':
+            case 'NO_USER_RESPONSE':
+                await this.transcript(errorCall, {
+                    action: 'Call No Answer',
+                    actionFromBot: true
+                });
+                await this.updateData();
+                return this.exitStep('no answer', errorCall);
+            default:
+                break;
+        }
+        await this.transcript(errorCall, {
+            action: 'Call Error',
+            actionFromBot: true
+        });
+        return this.throwError({
+            name: error?.name ?? 'VoiceError',
+            message: `${String(error?.date)}: ${errorStatus}`
+        });
+    }
+    async onCall(event, call) {
+        const { endUserNumber, 
+        // isAMD
+        asr } = this.data;
+        const newCall = {
+            headers: event.params.headers,
+            ...event.params.channel,
+            asr: asr.getSettings(),
+            // tts: tts.getVoice(),
+            botNumber: event.params.channel.to ?? 'unknown',
+            endUserNumber
+        };
+        delete newCall.from;
+        delete newCall.to;
+        newCall._conv = call._conv;
+        await this.startConversation(newCall);
+        await this.transcript(newCall, {
+            action: 'Call Start',
+            reportingSettingsKey: 'transcript',
+            actionFromBot: true
+        });
+        const commands = [
+            /* {
+              name: 'send-dtmf',
+              params: {
+                dtmf: '#',
+                afterDelay: 250,
+                beforeDelay: 250,
+                tonesDuration: 100,
+              }
+            },
+            {
+              name: 'record-session'
+            },
+            {
+              name: 'start-avmd',
+              params: {
+                type: 'avmd_detect'
+              }
+            } */
+            {
+                name: 'meet-ops',
+                params: {
+                    meetOps: {
+                        dtmfPin: '506 433 169 5884#'.replace(/ /g, ''),
+                        durationMs: 10 * 60 * 1000,
+                        idleTimeoutMs: 60 * 1000,
+                    },
+                }
+            }
+        ];
+        /* if (asr.serverSettings.enabled) {
+          commands.push({
+            name: 'start-recognition',
+            params: {
+              type: asr.serverSettings.engine
+            }
+          })
+        } */
+        await this.sendCommands(newCall, commands);
+        return this.exitStep('success');
+    }
     async originate(call) {
         const { id: callId } = call;
         const { 
@@ -42,7 +176,7 @@ class MeetOps extends voice_1.default {
         // tts,
         from: botNumber, endUserNumber: dianInNumber, sipHost, sipUser, sipPassword, timeout, headers, enableSpoofCallerId, spoofCallerId, 
         // isAMD,
-        otherCallRef, otherCallRefThread,
+        otherCallRef, otherCallRefThread, meetOps,
         // handleCancel
          } = this.data;
         const customHeadersEntities = headers?.map(({ name, value }) => [name, `${value}`]) || [];
@@ -51,12 +185,12 @@ class MeetOps extends voice_1.default {
             ? {
                 host: sipHost,
                 username: sipUser,
-                password: sipPassword
+                password: sipPassword,
             }
             : undefined;
         const spoofCallerIdConfig = {
             enableSpoofCallerId,
-            spoofCallerId
+            spoofCallerId,
         };
         const params = {
             id: callId,
@@ -68,8 +202,14 @@ class MeetOps extends voice_1.default {
             version: 2,
             gateway,
             timeout,
+            meetOps,
         };
         console.log(otherCallRef, otherCallRefThread, params);
+        await this.thread.emitAsync({
+            target: 'provider',
+            name: 'out/voice/originate/v2',
+            params,
+        });
         // const otherThread = this.process.getSafeThread(otherCallRefThread || this.thread.id)
         // const otherCall: IVoiceCall | undefined = await otherThread.get(otherCallRef)
         // if (otherCall == null) throw new Error(`otherCall not found: ${otherCallRef}`)

package/dst/Send DTMF.js

@@ -38,7 +38,7 @@ class SendDTMF extends voice_1.default {
         if (validationError != null)
             throw new Error(validationError.message);
         const command = {
-            name: 'meet-ops',
+            name: '-ops',
             params: {
                 dtmf,
                 meetOps: {

package/package.json

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