@fonoster/autopilot 0.5.0 → 0.5.2

package/dist/cerebro/cerebro.d.ts

@@ -11,16 +11,32 @@ export declare class Cerebro {
     voiceRequest: VoiceRequest;
     status: CerebroStatus;
     activationTimeout: number;
+    maxIteractionsBeforeHangup: number;
+    failedInteractions: number;
     activeTimer: NodeJS.Timer;
+    interactionTimer: NodeJS.Timer;
     intentsEngine: IntentsEngine;
     stream: SGatherStream;
     config: CerebroConfig;
     lastIntent: any;
     effects: EffectsManager;
+    interactionsTimer: NodeJS.Timeout;
+    isCallHandover: boolean;
+    isDead: boolean;
     constructor(config: CerebroConfig);
     wake(): Promise<void>;
     sleep(): Promise<void>;
     startActiveTimer(): void;
     resetActiveTimer(): void;
+    /**
+     * Start the interactions timer
+     * If the user doesn't say anything we should play the welcome message
+     * If it gets played twice many times we should hangup
+     * If the user says something we should reset the timer
+     * If we just finish an effect we should reset the timer
+     */
+    startInteractionTimer(): void;
+    resetInteractionTimer(): void;
     stopPlayback(): Promise<void>;
+    cleanup(): Promise<void>;
 }

package/dist/cerebro/cerebro.js

@@ -36,12 +36,18 @@ class Cerebro {
     voiceRequest;
     status;
     activationTimeout;
+    maxIteractionsBeforeHangup = 2;
+    failedInteractions = 0;
     activeTimer;
+    interactionTimer;
     intentsEngine;
     stream;
     config;
     lastIntent;
     effects;
+    interactionsTimer;
+    isCallHandover = false;
+    isDead = false;
     constructor(config) {
         this.voiceResponse = config.voiceResponse;
         this.voiceRequest = config.voiceRequest;
@@ -62,6 +68,10 @@ class Cerebro {
     // Subscribe to events
     async wake() {
         this.status = types_1.CerebroStatus.AWAKE_PASSIVE;
+        // This timer becomes active only if we don't have an activation intent
+        if (!this.config.activationIntentId) {
+            this.startInteractionTimer();
+        }
         this.voiceResponse.on("error", (error) => {
             this.cerebroEvents.emit("error", error);
             (0, logger_1.ulogger)({
@@ -81,16 +91,31 @@ class Cerebro {
         this.stream = await this.voiceResponse.sgather(speechConfig);
         this.stream.on("transcript", async (data) => {
             if (data.isFinal && data.transcript) {
+                logger.verbose("clear interactions timer", {
+                    sessionId: this.voiceRequest.sessionId
+                });
+                clearTimeout(this.interactionsTimer);
                 const intent = await this.intentsEngine.findIntent(data.transcript, {
                     telephony: {
                         caller_id: this.voiceRequest.callerNumber
                     }
                 });
                 logger.verbose("cerebro received new transcription from user", {
+                    sessionId: this.voiceRequest.sessionId,
                     text: data.transcript,
                     ref: intent.ref,
                     confidence: intent.confidence
                 });
+                if (intent.effects.find((e) => e.type === "hangup") ||
+                    intent.effects.find((e) => e.type === "transfer")) {
+                    logger.verbose("call hand over: stop all the timers and close the stream", {
+                        sessionId: this.voiceRequest.sessionId
+                    });
+                    clearTimeout(this.activeTimer);
+                    clearTimeout(this.interactionsTimer);
+                    this.voiceResponse.closeMediaPipe();
+                    this.isCallHandover = true;
+                }
                 await this.effects.invokeEffects(intent, this.status, async () => {
                     await this.stopPlayback();
                     if (this.config.activationIntentId === intent.ref) {
@@ -104,8 +129,32 @@ class Cerebro {
                             this.startActiveTimer();
                         }
                     }
+                }, () => {
+                    logger.verbose("invokeEffects cleanup callback", {
+                        sessionId: this.voiceRequest.sessionId
+                    });
+                    this.cleanup();
+                });
+                if (this.isDead || this.isCallHandover) {
+                    try {
+                        logger.verbose("the call was handover or cerebro was cleaned up", {
+                            sessionId: this.voiceRequest.sessionId
+                        });
+                        this.voiceResponse.hangup();
+                    }
+                    catch (e) {
+                        // All we can do is try as the call may have already been hung up
+                    }
+                    return;
+                }
+                logger.verbose("cerebro finished processing intent effects", {
+                    sessionId: this.voiceRequest.sessionId
                 });
-                // Need to save this to avoid duplicate intents
+                // Reset the interactions timer
+                if (!this.config.activationIntentId) {
+                    this.resetInteractionTimer();
+                }
+                // WARNING: It doesn't appear that we are using this anywhere
                 this.lastIntent = intent;
             }
         });
@@ -133,6 +182,57 @@ class Cerebro {
         clearTimeout(this.activeTimer);
         this.startActiveTimer();
     }
+    /**
+     * Start the interactions timer
+     * If the user doesn't say anything we should play the welcome message
+     * If it gets played twice many times we should hangup
+     * If the user says something we should reset the timer
+     * If we just finish an effect we should reset the timer
+     */
+    startInteractionTimer() {
+        logger.verbose("cerebro is starting interactions timer", {
+            sessionId: this.voiceRequest.sessionId
+        });
+        this.interactionsTimer = setInterval(async () => {
+            this.failedInteractions++;
+            logger.verbose("cerebro is counting interactions", {
+                sessionId: this.voiceRequest.sessionId,
+                failedInteractions: this.failedInteractions
+            });
+            let intentId = "welcome";
+            if (this.failedInteractions >= this.maxIteractionsBeforeHangup) {
+                logger.verbose("there was no interaction so for a long time so we hangup", {
+                    sessionId: this.voiceRequest.sessionId
+                });
+                intentId = "goodbye";
+                clearTimeout(this.interactionsTimer);
+            }
+            const intent = await this.intentsEngine.findIntentWithEvent(intentId, {
+                telephony: {
+                    caller_id: this.voiceRequest.callerNumber
+                }
+            });
+            await this.effects.invokeEffects(intent, this.status, () => {
+                logger.verbose("invokeEffects callback", {
+                    sessionId: this.voiceRequest.sessionId
+                });
+            }, () => {
+                logger.verbose("invokeEffects cleanup callback", {
+                    sessionId: this.voiceRequest.sessionId
+                });
+                this.cleanup();
+            });
+        }, this.activationTimeout);
+    }
+    resetInteractionTimer() {
+        logger.verbose("cerebro is reseting interactions timer", {
+            sessionId: this.voiceRequest.sessionId
+        });
+        // Reset the failed interactions timer
+        this.failedInteractions = 0;
+        clearTimeout(this.interactionsTimer);
+        this.startInteractionTimer();
+    }
     async stopPlayback() {
         const { playbackId } = this.config.voiceConfig;
         if (playbackId) {
@@ -151,5 +251,14 @@ class Cerebro {
             }
         }
     }
+    // Cleanup all timers and events
+    async cleanup() {
+        this.isDead = true;
+        await this.voiceResponse.closeMediaPipe();
+        this.stream.close();
+        this.cerebroEvents.removeAllListeners();
+        clearTimeout(this.activeTimer);
+        clearTimeout(this.interactionsTimer);
+    }
 }
 exports.Cerebro = Cerebro;

package/dist/cerebro/effects.d.ts

@@ -5,7 +5,7 @@ export declare class EffectsManager {
     voice: VoiceResponse;
     config: EffectsManagerConfig;
     constructor(config: EffectsManagerConfig);
-    invokeEffects(intent: Intent, status: CerebroStatus, activateCallback: Function): Promise<void>;
+    invokeEffects(intent: Intent, status: CerebroStatus, activateCallback: () => void, cleanupCallback: () => void): Promise<void>;
     run(effect: Effect): Promise<void>;
-    transferEffect(voice: VoiceResponse, effect: Effect): Promise<void>;
+    transferEffect(effect: Effect): Promise<void>;
 }

package/dist/cerebro/effects.js

@@ -15,8 +15,9 @@ class EffectsManager {
         this.voice = config.voice;
         this.config = config;
     }
-    async invokeEffects(intent, status, activateCallback) {
+    async invokeEffects(intent, status, activateCallback, cleanupCallback) {
         activateCallback();
+        logger.verbose("intent received", { intentRef: intent.ref });
         if (this.config.activationIntentId === intent.ref) {
             logger.verbose("fired activation intent");
             return;
@@ -28,9 +29,20 @@ class EffectsManager {
             // before we can have any effects
             return;
         }
+        // eslint-disable-next-line no-loops/no-loops
         for (const e of intent.effects) {
-            logger.verbose("effects running effect", { type: e.type });
-            await this.run(e);
+            try {
+                logger.verbose("effects running", { type: e.type });
+                await this.run(e);
+            }
+            catch (e) {
+                const axiosError = e;
+                if (axiosError.response?.status !== 404) {
+                    logger.error("error running effect", { error: e });
+                    return;
+                }
+                cleanupCallback();
+            }
         }
     }
     async run(effect) {
@@ -46,7 +58,7 @@ class EffectsManager {
                 break;
             case "transfer":
                 // TODO: Add record effect
-                await this.transferEffect(this.voice, effect);
+                await this.transferEffect(effect);
                 break;
             case "send_data":
                 // Only send if client support events
@@ -62,7 +74,7 @@ class EffectsManager {
                 throw new Error(`effects received unknown effect ${effect.type}`);
         }
     }
-    async transferEffect(voice, effect) {
+    async transferEffect(effect) {
         await this.voice.closeMediaPipe();
         const stream = await this.voice.dial(effect.parameters["destination"]);
         const playbackId = (0, nanoid_1.nanoid)();
@@ -73,16 +85,26 @@ class EffectsManager {
             await control.stop();
         };
         stream.on("answer", () => {
+            logger.verbose("call answered", {
+                destination: effect.parameters["destination"]
+            });
             moveForward();
         });
         stream.on("busy", async () => {
+            logger.verbose("call busy", {
+                destination: effect.parameters["destination"]
+            });
             await moveForward();
             await (0, helper_1.playBusyAndHangup)(this.voice, playbackId, this.config);
         });
         stream.on("noanswer", async () => {
+            logger.verbose("call no answer", {
+                destination: effect.parameters["destination"]
+            });
             await moveForward();
             await (0, helper_1.playNoAnswerAndHangup)(this.voice, playbackId, this.config);
         });
+        // eslint-disable-next-line no-loops/no-loops
         while (stay) {
             await (0, helper_1.playTransfering)(this.voice, playbackId, this.config);
         }

package/dist/envs.d.ts

@@ -1,2 +1,4 @@
 export declare const APISERVER_AUTOPILOT_PORT: number;
 export declare const APISERVER_AUTOPILOT_DEFAULT_LANGUAGE_CODE: string;
+export declare const APISERVER_AUTOPILOT_MEDIA_BUSY_MESSAGE: string;
+export declare const APISERVER_AUTOPILOT_MEDIA_NOANSWER_MESSAGE: string;

package/dist/envs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.APISERVER_AUTOPILOT_DEFAULT_LANGUAGE_CODE = exports.APISERVER_AUTOPILOT_PORT = void 0;
+exports.APISERVER_AUTOPILOT_MEDIA_NOANSWER_MESSAGE = exports.APISERVER_AUTOPILOT_MEDIA_BUSY_MESSAGE = exports.APISERVER_AUTOPILOT_DEFAULT_LANGUAGE_CODE = exports.APISERVER_AUTOPILOT_PORT = void 0;
 /*
  * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
  * http://github.com/fonoster/fonoster
@@ -23,3 +23,5 @@ exports.APISERVER_AUTOPILOT_PORT = process.env.APISERVER_AUTOPILOT_PORT
     ? parseInt(process.env.APISERVER_AUTOPILOT_PORT)
     : 6445;
 exports.APISERVER_AUTOPILOT_DEFAULT_LANGUAGE_CODE = process.env.APISERVER_AUTOPILOT_DEFAULT_LANGUAGE_CODE || "en-US";
+exports.APISERVER_AUTOPILOT_MEDIA_BUSY_MESSAGE = process.env.APISERVER_AUTOPILOT_MEDIA_BUSY_MESSAGE;
+exports.APISERVER_AUTOPILOT_MEDIA_NOANSWER_MESSAGE = process.env.APISERVER_AUTOPILOT_MEDIA_NOANSWER_MESSAGE;

package/dist/intents/dialogflow_es.js

@@ -128,10 +128,7 @@ class DialogFlow {
             ref: responses[0].queryResult.intent.displayName || "unknown",
             effects,
             confidence: responses[0].queryResult.intentDetectionConfidence || 0,
-            allRequiredParamsPresent: responses[0].queryResult
-                .allRequiredParamsPresent
-                ? true
-                : false
+            allRequiredParamsPresent: responses[0].queryResult.allRequiredParamsPresent
         };
     }
     getEffects(fulfillmentMessages) {

package/dist/pilot.js

@@ -30,11 +30,12 @@ const server_1 = require("./events/server");
 const nanoid_1 = require("nanoid");
 const engines_1 = require("./intents/engines");
 const util_1 = require("./util");
+const googleasr_1 = __importDefault(require("@fonoster/googleasr"));
 const logger_1 = require("@fonoster/logger");
 const googletts_1 = __importDefault(require("@fonoster/googletts"));
 const apps_1 = __importDefault(require("@fonoster/apps"));
 const secrets_1 = __importDefault(require("@fonoster/secrets"));
-const googleasr_1 = __importDefault(require("@fonoster/googleasr"));
+const envs_1 = require("./envs");
 const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
 function pilot(config) {
     logger.info("starting autopilot");
@@ -59,7 +60,7 @@ function pilot(config) {
             const apps = new apps_1.default(serviceCredentials);
             const secrets = new secrets_1.default(serviceCredentials);
             const app = await apps.getApp(voiceRequest.appRef);
-            logger.verbose(`requested app [ref: ${app.ref}]`, { app });
+            logger.verbose("requested app", { app, ref: app.ref });
             const ieSecret = await secrets.getSecret(app.intentsEngineConfig.secretName);
             const intentsEngine = (0, engines_1.getIntentsEngine)(app)(JSON.parse(ieSecret.secret));
             intentsEngine?.setProjectId(app.intentsEngineConfig.projectId);
@@ -88,22 +89,38 @@ function pilot(config) {
             (0, util_1.sendClientEvent)(eventsClient, {
                 eventName: types_1.CLIENT_EVENTS.ANSWERED
             });
-            if (app.initialDtmf)
+            if (app.initialDtmf) {
                 await voiceResponse.dtmf({ dtmf: app.initialDtmf });
+            }
             if (app.intentsEngineConfig.welcomeIntentId &&
                 intentsEngine.findIntentWithEvent) {
-                const response = await intentsEngine.findIntentWithEvent(app.intentsEngineConfig.welcomeIntentId, {
+                const response = await intentsEngine.findIntentWithEvent(
+                // TODO: This should be renamed to welcomeEventId
+                app.intentsEngineConfig.welcomeIntentId, {
                     telephony: {
                         caller_id: voiceRequest.callerNumber
                     }
                 });
                 if (response.effects.length > 0) {
-                    await voiceResponse.say(response.effects[0].parameters["response"], voiceConfig);
+                    // eslint-disable-next-line no-loops/no-loops
+                    for await (const effect of response.effects) {
+                        if (effect.type === "say") {
+                            await voiceResponse.say(effect.parameters["response"], voiceConfig);
+                        }
+                    }
                 }
                 else {
-                    logger.warn(`no effects found for welcome intent: trigger '${app.intentsEngineConfig.welcomeIntentId}'`);
+                    logger.warn("no effects found for welcome event", {
+                        eventId: app.intentsEngineConfig.welcomeIntentId
+                    });
                 }
             }
+            const transfer = app.transferConfig;
+            transfer.messageNoAnswer = transfer.messageBusy =
+                transfer.messageBusy || envs_1.APISERVER_AUTOPILOT_MEDIA_BUSY_MESSAGE;
+            transfer.messageNoAnswer =
+                transfer.messageNoAnswer ||
+                    envs_1.APISERVER_AUTOPILOT_MEDIA_NOANSWER_MESSAGE;
             const cerebro = new cerebro_1.Cerebro({
                 voiceRequest,
                 voiceResponse,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fonoster/autopilot",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "license": "MIT",
   "main": "dist/index",
   "types": "dist/index",
@@ -12,12 +12,12 @@
     "build": "tsc --build ./tsconfig.json"
   },
   "dependencies": {
-    "@fonoster/apps": "^0.5.0",
-    "@fonoster/googleasr": "^0.5.0",
-    "@fonoster/googletts": "^0.5.0",
-    "@fonoster/logger": "^0.5.0",
-    "@fonoster/secrets": "^0.5.0",
-    "@fonoster/voice": "^0.5.0",
+    "@fonoster/apps": "^0.5.1",
+    "@fonoster/googleasr": "^0.5.1",
+    "@fonoster/googletts": "^0.5.1",
+    "@fonoster/logger": "^0.5.1",
+    "@fonoster/secrets": "^0.5.1",
+    "@fonoster/voice": "^0.5.1",
     "@google-cloud/dialogflow": "^4.3.1",
     "@google-cloud/dialogflow-cx": "^2.13.0",
     "date-fns": "^2.29.3",
@@ -37,5 +37,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f3e53085462a1200c0c5fa086561f84c7d24895f"
+  "gitHead": "a6726245c50fc08aec29e04f7da04207b578a305"
 }