@fonoster/autopilot 0.4.15

package/dist/file-retention/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster
+ *
+ * This file is part of nodejs-voiceapp
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+__exportStar(require("./cron"), exports);

package/dist/file-retention/task.d.ts

@@ -0,0 +1,6 @@
+export type FileRetentionPolicyConfig = {
+    filesDirectory: string;
+    maxFileAge: number;
+    fileExtension: string;
+};
+export declare const runFileRetentionPolicy: (config: FileRetentionPolicyConfig) => void;

package/dist/file-retention/task.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFileRetentionPolicy = void 0;
+/* eslint-disable no-loops/no-loops */
+/*
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster
+ *
+ * This file is part of nodejs-voiceapp
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const date_fns_1 = require("date-fns");
+const logger_1 = require("@fonoster/logger");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+const runFileRetentionPolicy = (config) => {
+    logger.verbose("running file retention policy in directory: " + config.filesDirectory);
+    fs_1.default.readdir(config.filesDirectory, (err, files) => {
+        if (err)
+            throw err;
+        const ttsFiles = files.filter((file) => path_1.default.extname(file) === config.fileExtension);
+        logger.verbose("found " + ttsFiles.length + " files to be deleted");
+        for (const file of ttsFiles) {
+            const filePath = path_1.default.join(config.filesDirectory, file);
+            fs_1.default.stat(filePath, (err, stats) => {
+                if (err)
+                    throw err;
+                const diff = (0, date_fns_1.differenceInHours)(new Date(), stats.atime);
+                if (diff > config.maxFileAge) {
+                    logger.verbose("file " + file + " was last accessed " + diff + " hours ago");
+                    logger.verbose("deleting file " + file);
+                    fs_1.default.unlink(filePath, (err) => {
+                        if (err)
+                            throw err;
+                    });
+                }
+            });
+        }
+    });
+};
+exports.runFileRetentionPolicy = runFileRetentionPolicy;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const pilot_1 = __importDefault(require("./pilot"));
+(0, pilot_1.default)({
+    defaultLanguageCode: "en-US",
+    eventsServerEnabled: false,
+    port: 6445
+});

package/dist/intents/df_utils.d.ts

@@ -0,0 +1,3 @@
+import { Effect } from "../cerebro/types";
+export declare function getRamdomValue(values: Record<string, string>[]): Record<string, string>;
+export declare function transformPayloadToEffect(payload: Record<string, any>): Effect;

package/dist/intents/df_utils.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformPayloadToEffect = exports.getRamdomValue = void 0;
+function deserializePayload(object) {
+    const outputMessage = Array.isArray(object) ? [] : {};
+    Object.entries(object).forEach(([key, value]) => {
+        if (value.kind == "structValue") {
+            outputMessage[key] = deserializePayload(value.structValue.fields);
+        }
+        else if (value.kind == "listValue") {
+            outputMessage[key] = deserializePayload(value.listValue.values);
+        }
+        else if (value.kind == "stringValue") {
+            outputMessage[key] = value.stringValue;
+        }
+        else if (value.kind == "boolValue") {
+            outputMessage[key] = value.boolValue;
+        }
+        else {
+            outputMessage[key] = value;
+        }
+    });
+    return outputMessage;
+}
+function getRamdomValue(values) {
+    return values[Math.floor(Math.random() * values.length)];
+}
+exports.getRamdomValue = getRamdomValue;
+function transformPayloadToEffect(payload) {
+    const o = deserializePayload(payload.fields);
+    const parameters = o.effect === "say"
+        ? { response: getRamdomValue(o.parameters.responses) }
+        : o.parameters;
+    return {
+        type: o.effect,
+        parameters
+    };
+}
+exports.transformPayloadToEffect = transformPayloadToEffect;

package/dist/intents/dialogflow_cx.d.ts

@@ -0,0 +1,15 @@
+import { DialogFlowCXConfig, IntentsEngine, Intent } from "./types";
+import { SessionsClient } from "@google-cloud/dialogflow-cx";
+export default class DialogFlowCX implements IntentsEngine {
+    sessionClient: SessionsClient;
+    sessionPath: any;
+    config: DialogFlowCXConfig;
+    projectId: string;
+    location: string;
+    agent: string;
+    sessionId: string;
+    constructor(config: DialogFlowCXConfig);
+    setProjectId(id: string): void;
+    findIntent(txt: string): Promise<Intent>;
+    private getEffects;
+}

package/dist/intents/dialogflow_cx.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const df_utils_1 = require("./df_utils");
+const logger_1 = require("@fonoster/logger");
+const dialogflow_cx_1 = __importDefault(require("@google-cloud/dialogflow-cx"));
+const uuid = require("uuid");
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+class DialogFlowCX {
+    sessionClient;
+    sessionPath;
+    config;
+    projectId;
+    location;
+    agent;
+    sessionId;
+    constructor(config) {
+        const sessionId = uuid.v4();
+        this.projectId = config.projectId;
+        this.location = config.location;
+        this.config = config;
+        this.sessionId = sessionId;
+        this.agent = config.agent;
+        // Create a new session
+        this.sessionClient = new dialogflow_cx_1.default.SessionsClient({
+            apiEndpoint: `${config.location}-dialogflow.googleapis.com`,
+            credentials: config.credentials
+        });
+        logger.verbose("created new dialogflow/cx session", {
+            projectId: this.projectId,
+            sessionId: this.sessionId
+        });
+    }
+    setProjectId(id) {
+        this.projectId = id;
+    }
+    async findIntent(txt) {
+        const sessionPath = this.sessionClient.projectLocationAgentSessionPath(this.projectId, this.location, this.agent, this.sessionId);
+        const request = {
+            session: sessionPath,
+            queryInput: {
+                text: {
+                    text: txt
+                },
+                languageCode: this.config.languageCode
+            }
+        };
+        const responses = await this.sessionClient.detectIntent(request);
+        logger.silly("got speech from api", { text: JSON.stringify(responses[0]) });
+        if (!responses ||
+            !responses[0].queryResult ||
+            !responses[0].queryResult.responseMessages) {
+            throw new Error("got unexpect null intent");
+        }
+        const effects = this.getEffects(responses[0].queryResult.responseMessages);
+        const ref = responses[0].queryResult.intent
+            ? responses[0].queryResult.intent.displayName || "unknown"
+            : "unknown";
+        return {
+            ref,
+            effects,
+            confidence: responses[0].queryResult.intentDetectionConfidence || 0,
+            allRequiredParamsPresent: responses[0].queryResult.text ? true : false
+        };
+    }
+    getEffects(responseMessages) {
+        const effects = [];
+        for (const r of responseMessages) {
+            if (r.message === "text") {
+                effects.push({
+                    type: "say",
+                    parameters: {
+                        response: r.text.text[0]
+                    }
+                });
+                continue;
+            }
+            else if (r.payload) {
+                effects.push((0, df_utils_1.transformPayloadToEffect)(r.payload));
+            }
+        }
+        return effects;
+    }
+}
+exports.default = DialogFlowCX;

package/dist/intents/dialogflow_es.d.ts

@@ -0,0 +1,15 @@
+import * as dialogflow from "@google-cloud/dialogflow";
+import { IntentsEngine, Intent, DialogFlowESConfig } from "./types";
+export default class DialogFlow implements IntentsEngine {
+    sessionClient: dialogflow.v2beta1.SessionsClient;
+    sessionPath: any;
+    config: DialogFlowESConfig;
+    sessionId: string;
+    projectId: string;
+    constructor(config: DialogFlowESConfig);
+    setProjectId(projectId: string): void;
+    findIntentWithEvent(name: string, payload?: Record<string, unknown>): Promise<Intent>;
+    findIntent(txt: string, payload?: Record<string, unknown>): Promise<Intent>;
+    private detect;
+    private getEffects;
+}

package/dist/intents/dialogflow_es.js

@@ -0,0 +1,172 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-loops/no-loops */
+/* eslint-disable require-jsdoc */
+/*
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/rox
+ *
+ * This file is part of Rox AI
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const dialogflow = __importStar(require("@google-cloud/dialogflow"));
+const df_utils_1 = require("./df_utils");
+const pb_util_1 = require("pb-util");
+const logger_1 = require("@fonoster/logger");
+const uuid = require("uuid");
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+class DialogFlow {
+    sessionClient;
+    sessionPath;
+    config;
+    sessionId;
+    projectId;
+    constructor(config) {
+        this.sessionId = uuid.v4();
+        this.config = config;
+        this.projectId = config.projectId;
+        // Create a new session
+        this.sessionClient = new dialogflow.v2beta1.SessionsClient({
+            credentials: config.credentials
+        });
+        logger.verbose("created new dialogflow/es session", {
+            projectId: this.projectId,
+            sessionId: this.sessionId
+        });
+    }
+    setProjectId(projectId) {
+        this.projectId = projectId;
+    }
+    async findIntentWithEvent(name, payload) {
+        const request = {
+            queryInput: {
+                event: {
+                    name: name.toUpperCase(),
+                    languageCode: this.config.languageCode
+                }
+            }
+        };
+        return this.detect(request, payload);
+    }
+    async findIntent(txt, payload) {
+        const request = {
+            queryParams: {},
+            queryInput: {
+                text: {
+                    text: txt,
+                    languageCode: this.config.languageCode
+                }
+            }
+        };
+        return this.detect(request, payload);
+    }
+    async detect(request, payload) {
+        const sessionPath = this.sessionClient.projectAgentSessionPath(this.projectId, this.sessionId);
+        request.session = sessionPath;
+        if (payload) {
+            request.queryParams = {
+                payload: pb_util_1.struct.encode(payload)
+            };
+        }
+        const responses = await this.sessionClient.detectIntent(request);
+        logger.silly("got speech from api", { text: JSON.stringify(responses[0]) });
+        if (!responses ||
+            !responses[0].queryResult ||
+            !responses[0].queryResult.intent) {
+            throw new Error("got unexpect null intent");
+        }
+        let effects = [];
+        if (responses[0].queryResult.fulfillmentMessages) {
+            const messages = responses[0].queryResult.fulfillmentMessages.filter((f) => f.platform === this.config.platform);
+            effects = this.getEffects(messages);
+        }
+        else if (responses[0].queryResult.fulfillmentText) {
+            effects = [
+                {
+                    type: "say",
+                    parameters: {
+                        response: responses[0].queryResult.fulfillmentText
+                    }
+                }
+            ];
+        }
+        return {
+            ref: responses[0].queryResult.intent.displayName || "unknown",
+            effects,
+            confidence: responses[0].queryResult.intentDetectionConfidence || 0,
+            allRequiredParamsPresent: responses[0].queryResult
+                .allRequiredParamsPresent
+                ? true
+                : false
+        };
+    }
+    getEffects(fulfillmentMessages) {
+        const effects = [];
+        for (const f of fulfillmentMessages) {
+            if (f.payload) {
+                effects.push((0, df_utils_1.transformPayloadToEffect)(f.payload));
+            }
+            else if (f.telephonySynthesizeSpeech) {
+                effects.push({
+                    type: "say",
+                    parameters: {
+                        response: f.telephonySynthesizeSpeech.text ||
+                            f.telephonySynthesizeSpeech.ssml
+                    }
+                });
+            }
+            else if (f.telephonyTransferCall) {
+                effects.push({
+                    type: "transfer",
+                    parameters: {
+                        destination: f.telephonyTransferCall.phoneNumber
+                    }
+                });
+            }
+            else if (f.text) {
+                effects.push({
+                    type: "say",
+                    parameters: {
+                        response: f.text.text[0]
+                    }
+                });
+            }
+        }
+        return effects;
+    }
+}
+exports.default = DialogFlow;

package/dist/intents/engines.d.ts

@@ -0,0 +1,3 @@
+import { App } from "@fonoster/apps";
+import { IntentsEngine } from "./types";
+export declare function getIntentsEngine(app: App): (credentials: Record<string, string>) => IntentsEngine;

package/dist/intents/engines.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIntentsEngine = void 0;
+const dialogflow_cx_1 = __importDefault(require("./dialogflow_cx"));
+const dialogflow_es_1 = __importDefault(require("./dialogflow_es"));
+function getIntentsEngine(app) {
+    return function getEngine(credentials) {
+        const platform = app.intentsEngineConfig.emulateTelephonyPlatform
+            ? "TELEPHONY"
+            : "PLATFORM_UNSPECIFIED";
+        if ("location" in app.intentsEngineConfig) {
+            return new dialogflow_cx_1.default({
+                credentials,
+                projectId: app.intentsEngineConfig.projectId,
+                agent: app.intentsEngineConfig.agent,
+                location: app.intentsEngineConfig.location,
+                platform,
+                languageCode: "en-US"
+            });
+        }
+        return new dialogflow_es_1.default({
+            credentials,
+            projectId: app.intentsEngineConfig.projectId,
+            platform,
+            languageCode: "en-US"
+        });
+    };
+}
+exports.getIntentsEngine = getIntentsEngine;

package/dist/intents/types.d.ts

@@ -0,0 +1,26 @@
+import { Effect } from "../cerebro/types";
+export interface Intent {
+    ref: string;
+    effects: Effect[];
+    confidence: number;
+    allRequiredParamsPresent: boolean;
+}
+export interface IntentsEngine {
+    setProjectId: (id: string) => void;
+    findIntent: (text: string, payload?: Record<string, unknown>) => Promise<Intent>;
+    findIntentWithEvent?: (name: string, payload?: Record<string, unknown>) => Promise<Intent>;
+}
+export interface DialogFlowESConfig {
+    projectId: string;
+    languageCode: string;
+    platform: string;
+    credentials: Record<string, string>;
+}
+export interface DialogFlowCXConfig {
+    projectId: string;
+    languageCode: string;
+    location: string;
+    agent: string;
+    platform: string;
+    credentials: Record<string, string>;
+}

package/dist/intents/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/pilot.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { ServerConfig } from "./types";
+export default function pilot(config: ServerConfig): void;

package/dist/pilot.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable require-jsdoc */
+/*
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/rox
+ *
+ * This file is part of Rox AI
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const types_1 = require("./events/types");
+const voice_1 = require("@fonoster/voice");
+const cerebro_1 = require("./cerebro");
+const server_1 = require("./events/server");
+const nanoid_1 = require("nanoid");
+const engines_1 = require("./intents/engines");
+const util_1 = require("./util");
+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 logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+function pilot(config) {
+    logger.info("starting autopilot");
+    const voiceServer = new voice_1.VoiceServer({
+        port: config.port
+    });
+    if (config.eventsServerEnabled)
+        server_1.eventsServer.start();
+    logger.verbose("events server enabled = " + config.eventsServerEnabled);
+    voiceServer.listen(async (voiceRequest, voiceResponse) => {
+        logger.verbose(`new request [sessionId: ${voiceRequest.sessionId}]`, {
+            voiceRequest
+        });
+        try {
+            if (!voiceRequest.appRef)
+                throw new Error("invalid voice request: missing appRef");
+            // If set, we overwrite the configuration with the values obtain from the webhook
+            const serviceCredentials = {
+                accessKeyId: voiceRequest.accessKeyId,
+                accessKeySecret: voiceRequest.sessionToken
+            };
+            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 });
+            const ieSecret = await secrets.getSecret(app.intentsEngineConfig.secretName);
+            const intentsEngine = (0, engines_1.getIntentsEngine)(app)(JSON.parse(ieSecret.secret));
+            intentsEngine?.setProjectId(app.intentsEngineConfig.projectId);
+            const voiceConfig = {
+                name: app.speechConfig.voice,
+                playbackId: (0, nanoid_1.nanoid)()
+            };
+            const speechSecret = await secrets.getSecret(app.speechConfig.secretName);
+            const speechCredentials = {
+                private_key: JSON.parse(speechSecret.secret).private_key,
+                client_email: JSON.parse(speechSecret.secret).client_email
+            };
+            voiceResponse.use(new googletts_1.default({
+                credentials: speechCredentials,
+                languageCode: config.defaultLanguageCode,
+                path: config.fileRetentionPolicyDirectory
+            }));
+            voiceResponse.use(new googleasr_1.default({
+                credentials: speechCredentials,
+                languageCode: config.defaultLanguageCode
+            }));
+            await voiceResponse.answer();
+            const eventsClient = app.enableEvents && config.eventsServerEnabled
+                ? server_1.eventsServer.getConnection(voiceRequest.callerNumber)
+                : null;
+            (0, util_1.sendClientEvent)(eventsClient, {
+                eventName: types_1.CLIENT_EVENTS.ANSWERED
+            });
+            if (app.initialDtmf)
+                await voiceResponse.dtmf({ dtmf: app.initialDtmf });
+            if (app.intentsEngineConfig.welcomeIntentId &&
+                intentsEngine.findIntentWithEvent) {
+                const response = await intentsEngine.findIntentWithEvent(app.intentsEngineConfig.welcomeIntentId, {
+                    telephony: {
+                        caller_id: voiceRequest.callerNumber
+                    }
+                });
+                if (response.effects.length > 0) {
+                    await voiceResponse.say(response.effects[0].parameters["response"], voiceConfig);
+                }
+                else {
+                    logger.warn(`no effects found for welcome intent: trigger '${app.intentsEngineConfig.welcomeIntentId}'`);
+                }
+            }
+            const cerebro = new cerebro_1.Cerebro({
+                voiceRequest,
+                voiceResponse,
+                eventsClient,
+                voiceConfig,
+                intentsEngine,
+                activationIntentId: app.activationIntentId,
+                activationTimeout: app.activationTimeout,
+                transfer: app.transferConfig,
+                alternativeLanguageCode: app.speechConfig.languageCode
+            });
+            // Open for bussiness
+            await cerebro.wake();
+        }
+        catch (e) {
+            (0, logger_1.ulogger)({
+                accessKeyId: voiceRequest.accessKeyId,
+                eventType: logger_1.ULogType.APP,
+                level: "error",
+                message: e.message
+            });
+        }
+    });
+}
+exports.default = pilot;