@tiledesk/tiledesk-voice-twilio-connector 0.1.28 → 0.2.0-rc3

package/src/controllers/VoiceController.original.js

@@ -0,0 +1,811 @@
+const { TiledeskChannel } = require('../services/channels/TiledeskChannel');
+const { TiledeskTwilioTranslator } = require('../services/translators/TiledeskTwilioTranslator');
+const utilsMessage = require('../utils/utils-message');
+const utils = require('../utils/utils');
+const { TYPE_MESSAGE, CHANNEL_NAME, VOICE_LANGUAGE, VOICE_NAME, CALL_STATUS, VOICE_PROVIDER } = require('../utils/constants');
+const logger = require('../utils/logger');
+const querystring = require('querystring');
+
+class VoiceController {
+    constructor(services) {
+        this.aiService = services.aiService;
+        this.uploadService = services.uploadService;
+        this.integrationService = services.integrationService;
+        this.voiceChannel = services.voiceChannel;
+        this.db = services.db;
+        this.redisClient = services.redisClient;
+        this.config = services.config;
+
+        this.tdChannel = new TiledeskChannel({
+            API_URL: this.config.API_URL,
+            redis_client: this.redisClient
+        });
+
+        this.tdTranslator = new TiledeskTwilioTranslator({
+            BASE_URL: this.config.BASE_URL,
+            aiService: this.aiService,
+            uploadService: this.uploadService
+        });
+    }
+
+    async index(req, res) {
+        res.send("Tiledesk Voice Connector");
+    }
+
+    async tiledesk(req, res) {
+        try {
+            logger.debug("(voice) Message received from Tiledesk in projectID: " + req.body.payload.id_project + ' ---- and text: ' + req.body.payload.text);
+            let tiledeskMessage = req.body.payload;
+            let project_id = tiledeskMessage.id_project;
+
+            /*SKIP INFO MESSAGES*/
+            /*SKIP CURRENT USER MESSAGES*/
+            if (!utilsMessage.messageType(TYPE_MESSAGE.INFO, tiledeskMessage) && !(tiledeskMessage.sender.indexOf("vxml") > -1)) {
+                logger.debug(`> whook SAVE MESSAGE "${tiledeskMessage.text}" TO QUEUE at time ` + new Date());
+            }
+
+            if (await this.tdChannel.addMessageToQueue(tiledeskMessage)) {
+                if (tiledeskMessage.attributes && tiledeskMessage.attributes.flowAttributes && tiledeskMessage.attributes.flowAttributes.CallSid && this.tdTranslator.lastCallSidVerb[tiledeskMessage.attributes.flowAttributes.CallSid] == 'play') {
+
+                    const CONTENT_KEY = CHANNEL_NAME + "-" + project_id;
+                    let settings = await this.db.get(CONTENT_KEY);
+
+                    const twilio = require('twilio')(settings.account_sid, settings.auth_token);
+                    const callSid = tiledeskMessage.attributes.flowAttributes.CallSid;
+                    const queryString = '?intentName=' + querystring.encode(tiledeskMessage.attributes.intentName) + '&previousIntentTimestamp=' + Date.now();
+                    try {
+                        await twilio.calls(callSid).update({
+                            url: `${this.config.BASE_URL}/nextblock/${callSid}${queryString}`,
+                            method: 'POST'
+                        });
+                        logger.debug(`(voice) Call ${callSid} redirected to /nextblock`);
+                    } catch (e) {
+                        logger.error('(voice) Error redirecting call to /nextblock:', e)
+                    }
+                }
+            }
+
+
+            res.send("(voice) Message received from Voice Twilio Proxy");
+        } catch (error) {
+            logger.error("(voice) Error in tiledesk handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async webhook(req, res) {
+        try {
+            let start_call = new Date().getTime();
+            logger.debug('(voice) called POST /webhook/:id_project ' + new Date(), req.params);
+
+            let project_id = req.params.id_project;
+            let callSid = req.body.CallSid;
+            let from = req.body.From;
+            let to = req.body.To;
+
+            if ((!from || !to) && from !== "client:Anonymous") {
+                return res.status(404).send({ error: "Error: Missing from/to parameters" });
+            }
+            from = utils.getNumber(from); //remove '+' from number
+            if (to) {
+                to = utils.getNumber(to); //remove '+' from number
+            } else {
+                to = "client:AnonymousReceiver";
+            }
+
+            const CONTENT_KEY = CHANNEL_NAME + "-" + project_id;
+            let settings = await this.db.get(CONTENT_KEY);
+            if (!settings) {
+                return res.status(404).send({ error: "VOICE Channel not already connected" });
+            }
+
+            let vxmlAttributes = {
+                TTS_VOICE_LANGUAGE: VOICE_LANGUAGE,
+                TTS_VOICE_NAME: VOICE_NAME,
+                callSid: callSid
+            };
+
+            let start2 = new Date().getTime();
+            let user = await this.tdChannel.signIn(from, settings);
+            if (!user) {
+                res.status(401).send({ message: "Cannot able to signIn with current caller phone :" + from });
+                return;
+            }
+            let end2 = new Date().getTime();
+
+            // Parallelize conversation generation and integration key retrieval
+            let [conversation_id, openaiKeyResult, elevenLabsKey] = await Promise.all([
+                this.tdChannel.generateConversation(from, callSid, project_id),
+
+                // Retrieve OpenAI key (with sequential fallback)
+                (async () => {
+                    try {
+                        let key = await this.integrationService.getKeyFromIntegrations(project_id, 'openai', settings.token)
+                        if (!key) {
+                            logger.debug("(voice) - Key not found in Integrations. Searching in kb settings...");
+                            key = await this.integrationService.getKeyFromKbSettings(project_id, settings.token);
+                        }
+                        if (!key) {
+                            logger.debug("(voice) - Retrieve public gptkey")
+                            key = this.config.GPT_KEY;
+                            return { key, publicKey: true };
+                        }
+                        return { key, publicKey: false };
+                    } catch (error) {
+                        logger.error('(voice) - Error retrieving OpenAI key:', error);
+                        return { key: this.config.GPT_KEY, publicKey: true };
+                    }
+                })(),
+
+                // Retrieve ElevenLabs key in parallel
+                this.integrationService.getKeyFromIntegrations(project_id, 'elevenlabs', settings.token).catch((error) => {
+                    logger.error('(voice) - Error retrieving ElevenLabs key:', error);
+                    return null;
+                })
+            ]);
+
+            logger.debug("(voice) conversation returned:" + conversation_id);
+
+            // Build integrations array
+            let integrations = [];
+            if (openaiKeyResult && openaiKeyResult.key) {
+                integrations.push({ type: 'openai', key: openaiKeyResult.key, publicKey: openaiKeyResult.publicKey })
+            }
+            if (elevenLabsKey) {
+                logger.debug("(voice) - Key found in Integrations: " + elevenLabsKey);
+                integrations.push({ type: 'elevenlabs', key: elevenLabsKey, publicKey: false })
+            }
+
+            //save data to redis
+            let session_data = {
+                from: from,
+                to: to,
+                callSid: callSid,
+                project_id: project_id,
+                user: user,
+                conversation_id: conversation_id,
+                integrations: integrations
+            }
+            this.voiceChannel.setSessionForCallId(callSid, session_data)
+
+            let tiledeskMessage = {
+                text: '/start',
+                senderFullname: from,
+                type: 'text',
+                attributes: {
+                    subtype: 'info',
+                    payload: {
+                        ...req.body //send all attributes back to chatbot
+                    }
+                },
+                channel: { name: CHANNEL_NAME },
+                departmentid: settings.department_id
+            };
+
+            let response = await this.tdChannel.send(tiledeskMessage, user.token, conversation_id, project_id)
+            if (!response) {
+                return res.status(503).send({ message: "Bad response: Quota exceeded" })
+            }
+
+            //await for a response message from tiledesk queue
+            let start_time_get_message = new Date()
+            let message = await this._getMessage(callSid, from, project_id, conversation_id, this.tdChannel)
+            let end_time_get_message = new Date()
+            logger.verbose(`Time to getMessage from queue in /webhook/:${project_id} :  ${(end_time_get_message - start_time_get_message)}[ms] --- at time:` + new Date())
+
+            // send standard wait vxml message
+            let messageToVXML = await this.tdTranslator.toVXML(message, callSid, vxmlAttributes, session_data)
+            logger.debug('(voice) /webhook/:id_project messageVXML-->' + messageToVXML)
+
+            let end_call1 = new Date().getTime();
+            logger.info(`Time to respond to /webhook/${project_id} before response:  ${(end_call1 - start_call)}[ms]`)
+
+            // Render the response as XML in reply to the webhook request
+            res.set('Content-Type', 'text/xml');
+            res.status(200).send(messageToVXML);
+
+            let end_call2 = new Date().getTime();
+            logger.info(`Time to respond to /webhook/${project_id}:  ${(end_call2 - start_call)}[ms]`)
+
+        } catch (error) {
+            logger.error("(voice) Error in webhook handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async _initializeContext(callSid) {
+        const sessionInfo = await this.voiceChannel.getSessionForCallId(callSid);
+        if (!sessionInfo) {
+            throw new Error("Can't retrieve data for callSid -> " + callSid);
+        }
+
+        const { project_id, from, conversation_id, user } = sessionInfo;
+
+        const vxmlAttributes = {
+            TTS_VOICE_LANGUAGE: VOICE_LANGUAGE,
+            TTS_VOICE_NAME: VOICE_NAME,
+            callSid: callSid,
+        };
+
+        return { sessionInfo, project_id, from, conversation_id, user, vxmlAttributes };
+    }
+
+    /**
+     * Process user speech/text input and return VXML response.
+     * Shared logic for nextblock and speechresult handlers.
+     * @param {string} usertext - The speech result text
+     * @param {string} callSid - The call session ID
+     * @param {string} endpoint - Endpoint name for logging
+     * @returns {Promise<{message: Object, vxmlAttributes: Object, sessionInfo: Object}>}
+     */
+    async _processUserSpeech(usertext, callSid, endpoint) {
+        const { sessionInfo, project_id, from, conversation_id, user, vxmlAttributes } = await this._initializeContext(callSid);
+
+        let message;
+        logger.debug(`(voice) ******* user text --> ${usertext}`);
+
+        if (!usertext) {
+            const start = Date.now();
+            message = await this._getMessage(callSid, from, project_id, conversation_id, this.tdChannel);
+            logger.verbose(`(if) Time to getMessage from queue in /${endpoint}/${callSid} : ${Date.now() - start}[ms]`);
+        } else {
+            const tiledeskMessage = {
+                text: usertext,
+                senderFullname: from,
+                type: 'text',
+                channel: { name: CHANNEL_NAME }
+            };
+
+            const sendStart = Date.now();
+            const tdMessage = await this.tdChannel.send(tiledeskMessage, user.token, conversation_id, project_id);
+            logger.verbose(`(else) Time to send message to tiledesk in /${endpoint}/${callSid} : ${Date.now() - sendStart}[ms] with text ${tdMessage?.text}`);
+
+            const getStart = Date.now();
+            message = await this._getMessage(callSid, from, project_id, conversation_id, this.tdChannel);
+            logger.verbose(`(else) Time to getMessage from queue in /${endpoint}/${callSid} : ${Date.now() - getStart}[ms]`);
+        }
+
+        return { message, vxmlAttributes, sessionInfo, callSid };
+    }
+
+    async nextblock(req, res) {
+        try {
+            const start_call = Date.now();
+            logger.verbose(`(voice) called POST /nextblock at ${new Date()} with text: ${req.body.SpeechResult}`);
+
+            const { message, vxmlAttributes, sessionInfo, callSid } = await this._processUserSpeech(
+                req.body.SpeechResult,
+                req.params.callSid,
+                'nextblock'
+            );
+
+            const messageToVXML = await this.tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo);
+            logger.debug("(voice) VXML to SEND: " + messageToVXML);
+            logger.info(`Time to respond to /nextblock/${callSid} : ${Date.now() - start_call}[ms]`);
+
+            res.set('Content-Type', 'application/xml');
+            res.status(200).send(messageToVXML);
+        } catch (error) {
+            logger.error("(voice) Error in nextblock handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async speechresult(req, res) {
+        try {
+            const start_call = Date.now();
+            logger.verbose(`(voice) called POST /speechresult at ${new Date()} with text: ${req.body.SpeechResult}`);
+
+            const { message, vxmlAttributes, sessionInfo, callSid } = await this._processUserSpeech(
+                req.body.SpeechResult,
+                req.params.callSid,
+                'speechresult'
+            );
+
+            const messageToVXML = await this.tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo);
+            logger.debug("(voice) VXML to SEND: " + messageToVXML);
+            logger.info(`Time to respond to /speechresult/${callSid} : ${Date.now() - start_call}[ms]`);
+
+            res.set('Content-Type', 'application/xml');
+            res.status(200).send(messageToVXML);
+        } catch (error) {
+            logger.error("(voice) Error in speechresult handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async recordAction(req, res) {
+        try {
+            logger.verbose('+++++++++++(voice) called POST record/action/:callSid at time ' + new Date() + "at timestamp " + new Date().getTime());
+            let start_call = new Date();
+
+            let callSid = req.body.CallSid;
+
+            const { sessionInfo, project_id, from, conversation_id, vxmlAttributes } = await this._initializeContext(callSid);
+
+            let start_time_get_message = new Date()
+            let message = await this._getMessage(callSid, from, project_id, conversation_id, this.tdChannel)
+            logger.debug('message from getMessage in /record/action/: ', message)
+            let end_time_get_message = new Date()
+            logger.verbose(`Time to getMessage from queue in /record/action/${callSid} : ${(end_time_get_message - start_time_get_message)}[ms]` + ' --- at time:' + new Date())
+
+
+            // convert response to vxml
+            let messageToVXML = await this.tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
+            logger.debug("(voice) /record/action VXML to SEND: " + messageToVXML);
+
+            let end_call = new Date();
+            logger.info(`Time to respond to /record/action/${callSid} :  ${(end_call - start_call)}[ms]`)
+            res.set('Content-Type', 'application/xml');
+            res.status(200).send(messageToVXML);
+        } catch (error) {
+            logger.error("(voice) Error in recordAction handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async recordCallback(req, res) {
+        try {
+            logger.verbose('+++++++++++(voice) called POST record/callback/:callSid at time' + new Date() + "at timestamp " + new Date().getTime());
+            let start_call = new Date();
+
+            let callSid = req.params.callSid || req.body.CallSid;
+            let audioFileUrl = req.body.RecordingUrl;
+            let button_action = req.query.button_action ? '#' + req.query.button_action : '';
+            let previousIntentName = req.query.intentName || '';
+
+            const { sessionInfo, project_id, from, conversation_id, user } = await this._initializeContext(callSid);
+
+            const CONTENT_KEY = CHANNEL_NAME + "-" + project_id;
+            let settings = await this.db.get(CONTENT_KEY);
+            if (!settings) {
+                return res.status(404).send({ error: "VOICE Channel not already connected" })
+            }
+
+            let tiledeskMessage = null;
+
+            //SPEECH TO TEXT
+            const attributes = await this.voiceChannel.getSettingsForCallId(callSid);
+            logger.debug(`[VOICE] getting text message from STT: ${audioFileUrl}, model: ${attributes.STT_MODEL}`);
+            // generateSTT ritorna sempre un oggetto coerente (anche vuoto o /close)
+            tiledeskMessage = await this._generateSTT(audioFileUrl, attributes, sessionInfo, settings)
+            logger.debug('[VOICE] tiledeskMessage from STT: ', tiledeskMessage)
+            if (!tiledeskMessage || Object.keys(tiledeskMessage).length === 0) {
+                logger.debug(`[VOICE] STT result empty, fallback to no_input branch for callSid ${callSid}`);
+                tiledeskMessage = this._buildNoInputMessage('no_input', { from, button_action, payload: { event: 'no_input', lastBlock: previousIntentName, lastTimestamp: Date.now() } });
+            } else {
+                const normalizedText = utils.normalizeSTT(tiledeskMessage.text);
+                logger.verbose(`[VOICE] normalized STT text: ${normalizedText} for callSid ${callSid}`);
+                if (!normalizedText) {
+                    tiledeskMessage = this._buildNoInputMessage('no_input', { from, button_action, payload: { event: 'no_input', lastBlock: previousIntentName, lastTimestamp: Date.now() } });
+                } else {
+                    tiledeskMessage.text = normalizedText;
+                }
+            }
+
+            //send message to tiledesk
+            let tdMessage = await this.tdChannel.send(tiledeskMessage, user.token, conversation_id, project_id);
+            let end_call = new Date();
+            logger.info(`Time to respond to /record/callback/${callSid} :  ${(end_call - start_call)} [ms] with text ` + tiledeskMessage.text);
+
+            res.status(200).send({ success: true, message: "Message sent to Tiledesk for callSid " + callSid });
+        } catch (error) {
+            logger.error("(voice) Error in recordCallback handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async menublock(req, res) {
+        try {
+            let start_call = new Date().getTime();
+            logger.debug("(voice) called POST /menu", req.body);
+            logger.debug("(voice) called POST /menu query", req.query);
+            logger.verbose('/menublock at: ' + new Date() + 'with text:' + req.body.Digits)
+
+            let message_text = '';
+            let attributes = {};
+            let button = {}
+
+            let callSid = req.params.callSid;
+            let buttons_menu = req.query.menu_options;
+            let buttonNoMatch = req.query.button_action;
+
+            let menu_choice = req.body.Digits || '';
+
+            /** use case: DTMF MENU **/
+            if (buttons_menu) {
+                buttons_menu.split(';').some((option) => {
+                    option = option.split(':')
+                    if (option[0] === menu_choice) {
+                        button.value = option[0]
+                        button.action = '#' + option[1]
+                        return true;
+                    }
+                })
+
+
+                /* case noMatch input: Digits is not in a valid menu option*/
+                if (Object.keys(button).length === 0) {
+                    button.value = menu_choice
+                    button.action = '#' + buttonNoMatch
+                }
+
+                message_text = button.value.toString();
+                attributes = {
+                    action: button.action
+                }
+
+            } else {
+                /** use case: DTMF Speech **/
+                message_text = menu_choice.toString(); //.replace(/(\d)/g, '$1 '); //convert number to string and then add a space after each number
+            }
+
+            logger.debug("(voice) button menu: ", button);
+            logger.debug("(voice) message_text menu: " + message_text);
+
+            const { sessionInfo, project_id, from, conversation_id, user, vxmlAttributes } = await this._initializeContext(callSid);
+
+            //send message to tiledesk 
+            let tiledeskMessage = {
+                text: message_text,
+                senderFullname: from,
+                type: 'text',
+                channel: { name: CHANNEL_NAME },
+                attributes: attributes
+            };
+            let response = await this.tdChannel.send(tiledeskMessage, user.token, conversation_id, project_id);
+            if (!response) {
+                return res.status(503).send({ message: "Bad response: Quota exceeded" })
+            }
+
+            let start_time_get_message = new Date()
+            let message = await this._getMessage(callSid, from, project_id, conversation_id, this.tdChannel)
+            let end_time_get_message = new Date()
+            logger.verbose(`Time to getMessage from queue in /menublock/${callSid} : ${(end_time_get_message - start_time_get_message)}[ms]` + ' --- at time:' + new Date())
+
+            // convert response to vxml
+            let messageToVXML = await this.tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
+            logger.debug("(voice) VXML to SEND: " + messageToVXML);
+
+            let end_call = new Date().getTime();
+            logger.info(`Time to respond to /menublock/${callSid} :  ${(end_call - start_call)} [ms]`)
+
+            res.set('Content-Type', 'application/xml');
+            res.status(200).send(messageToVXML);
+        } catch (error) {
+            logger.error("(voice) Error in menublock handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async handleEvent(req, res) {
+        try {
+            logger.debug("(voice) called POST /handle", req.body);
+            logger.debug("(voice) called POST /handle query -->", req.query);
+            logger.debug("(voice) called POST /handle params-->", req.params);
+
+            let event = req.params.event;
+            let callSid = req.params.callSid;
+            let button_action = '#' + req.query.button_action;
+            let previousIntentName = req.query.intentName;
+
+            const { sessionInfo, project_id, from, conversation_id, user, vxmlAttributes } = await this._initializeContext(callSid);
+
+            //send message to tiledesk 
+            let tiledeskMessage = {
+                text: "/" + event,
+                senderFullname: from,
+                type: 'text',
+                channel: { name: CHANNEL_NAME },
+                attributes: {
+                    type: 'info',
+                    action: button_action,
+                    payload: {
+                        event: event,
+                        lastBlock: previousIntentName,
+                        lastTimestamp: Date.now()
+                    }
+                }
+            };
+            let tdMessage = await this.tdChannel.send(tiledeskMessage, user.token, conversation_id, project_id);
+
+            //generate Tiledesk wait message
+            let delayTime = await this.voiceChannel.getNextDelayTimeForCallId(callSid)
+            let message = await this.tdChannel.generateWaitTdMessage(callSid, delayTime)
+            ///update delayIndex for wait command message time
+            await this.voiceChannel.saveDelayIndexForCallId(callSid)
+
+            // convert response to vxml
+            let messageToVXML = await this.tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
+            logger.debug("(voice) VXML to SEND: " + messageToVXML);
+
+            res.set('Content-Type', 'application/xml');
+            res.status(200).send(messageToVXML);
+        } catch (error) {
+            logger.error("(voice) Error in handleEvent handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async event(req, res) {
+        try {
+            logger.debug("(voice) called POST /event", req.params);
+            logger.debug("(voice) called POST /event query", req.query);
+            logger.debug("(voice) called POST /event body", req.body);
+
+            let event = req.params.event;
+            let callSid = req.params.callSid;
+            let currentIntentName = req.query.intentName;
+            let currentIntentTimestamp = req.query.previousIntentTimestamp;
+
+            const { sessionInfo, project_id, from, conversation_id, user, vxmlAttributes } = await this._initializeContext(callSid);
+
+            let button_action = ''
+            if (event === 'transfer') {
+                let callStatus = req.body.CallStatus;
+                switch (callStatus) {
+                    case CALL_STATUS.COMPLETED:
+                        button_action = '#' + req.query.button_success;
+                        break;
+                    case CALL_STATUS.FAILED:
+                        button_action = '#' + req.query.button_failure;
+                        break;
+                }
+
+                switch (callStatus) {
+                    case CALL_STATUS.COMPLETED:
+                    case CALL_STATUS.FAILED: {
+                        //send message to tiledesk 
+                        let tiledeskMessage = {
+                            //text:'\\close',
+                            text: '/' + event,
+                            senderFullname: from,
+                            type: 'text',
+                            channel: { name: CHANNEL_NAME },
+                            attributes: {
+                                subtype: "info",
+                                action: button_action,
+                                payload: {
+                                    event: event,
+                                    lastBlock: currentIntentName,
+                                    lastTimestamp: currentIntentTimestamp
+                                }
+                            }
+                        };
+                        let tdMessage = await this.tdChannel.send(tiledeskMessage, user.token, conversation_id, project_id);
+                    }
+                }
+
+            }
+
+
+            //generate Tiledesk wait message
+            let delayTime = await this.voiceChannel.getNextDelayTimeForCallId(callSid)
+            let message = await this.tdChannel.generateWaitTdMessage(callSid, delayTime)
+            ///update delayIndex for wait command message time
+            await this.voiceChannel.saveDelayIndexForCallId(callSid)
+
+            // convert response to vxml
+            let messageToVXML = await this.tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
+            logger.debug("(voice) VXML to SEND: " + messageToVXML);
+
+            res.set('Content-Type', 'application/xml');
+            res.status(200).send(messageToVXML);
+        } catch (error) {
+            logger.error("(voice) Error in event handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async twilioStatus(req, res) {
+        try {
+            logger.debug('+++++++++++(voice) called POST twilio/status ', req.body);
+
+            let event = req.body.CallStatus;
+            let callSid = req.body.CallSid;
+
+            const { sessionInfo, project_id, from, conversation_id, user } = await this._initializeContext(callSid);
+
+            switch (event) {
+                case CALL_STATUS.COMPLETED: {
+                    //send message to tiledesk 
+                    let tiledeskMessage = {
+                        //text:'\\close',
+                        text: '/close',
+                        senderFullname: from,
+                        type: 'text',
+                        channel: { name: CHANNEL_NAME },
+                        attributes: {
+                            subtype: "info",
+                            action: 'close' + JSON.stringify({ event: event }),
+                            payload: {
+                                catchEvent: event
+                            },
+                            timestamp: 'xxxxxx'
+                        }
+                    };
+
+                    let tdMessage = await this.tdChannel.send(tiledeskMessage, user.token, conversation_id, project_id);
+
+                    //remove session data for current callId and relative queue data
+                    await this.voiceChannel.deleteCallKeys(callSid);
+                    await this.tdChannel.clearQueue(conversation_id);
+                    break;
+                }
+            }
+
+            res.status(200).send();
+        } catch (error) {
+            logger.error("(voice) Error in twilioStatus handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async twilioFail(req, res) {
+        logger.debug('+++++++++++(voice) called POST twilio/fail ', req.params)
+        logger.debug('+++++++++++(voice) called POST twilio/fail ', req.body)
+
+        res.set('Content-Type', 'application/xml');
+        res.status(200).send('<Response></Response>');
+    }
+
+    async _generateSTT(audioFileUrl, attributes, sessionInfo, settings) {
+
+        logger.debug("(voice) generateSTT: " + attributes.VOICE_PROVIDER);
+
+        let tiledeskMessage = {};
+        let text = null;
+
+        try {
+            switch (attributes.VOICE_PROVIDER) {
+                case VOICE_PROVIDER.OPENAI: {
+                    let GPT_KEY = sessionInfo.integrations.find((el => el.type === VOICE_PROVIDER.OPENAI))?.key
+                    let publicKey = sessionInfo.integrations.find((el => el.type === VOICE_PROVIDER.OPENAI))?.publicKey
+                    if (publicKey) {
+                        let keep_going = await this.aiService.checkQuoteAvailability(sessionInfo.project_id, settings.token)
+                        logger.debug('(voice) checkQuoteAvailability return: ' + keep_going);
+                        if (!keep_going) {
+                            //no token is available --> close conversation
+                            return tiledeskMessage = {
+                                //text:'\\close',
+                                text: '/close',
+                                senderFullname: sessionInfo.from,
+                                type: 'text',
+                                channel: { name: CHANNEL_NAME },
+                                attributes: {
+                                    subtype: "info",
+                                    action: 'close' + JSON.stringify({ event: 'quota_exceeded' }),
+                                    payload: {
+                                        catchEvent: 'quota_exceeded'
+                                    },
+                                    timestamp: 'xxxxxx'
+                                }
+                            };
+
+                        }
+                    }
+
+                    text = await this.aiService.speechToText(audioFileUrl, attributes.STT_MODEL, GPT_KEY)
+                    break;
+                }
+                case VOICE_PROVIDER.ELEVENLABS: {
+                    let ELEVENLABS_APIKEY = sessionInfo.integrations.find((el => el.type === VOICE_PROVIDER.ELEVENLABS))?.key
+                    const ttsLanguage = attributes.TTS_LANGUAGE || 'en';
+                    text = await this.aiService.speechToTextElevenLabs(audioFileUrl, attributes.STT_MODEL, ttsLanguage, ELEVENLABS_APIKEY)
+                    break;
+                }
+                default:
+                    throw new Error('Unsupported VOICE_PROVIDER: ' + attributes.VOICE_PROVIDER);
+            }
+
+            if (text) {
+                logger.debug('[STT] text empty → fallback no_input');
+                tiledeskMessage = {
+                    text: text,
+                    senderFullname: sessionInfo.from,
+                    type: 'text',
+                    channel: { name: CHANNEL_NAME }
+                };
+            }
+        } catch (error) {
+            logger.error('[STT] generateSTT error:', error);
+            switch (error.code) {
+                case 'AISERVICE_FAILED':
+                    logger.error('[STT] AISERVICE_FAILED → ', error.message);
+                    break;
+            }
+
+            // fallback: tiledeskMessage vuoto
+            tiledeskMessage = {};
+
+        }
+
+        return tiledeskMessage
+    }
+
+    _buildNoInputMessage(event, { from, button_action, payload }) {
+        return {
+            text: `/${event}`,
+            senderFullname: from,
+            type: 'text',
+            channel: { name: CHANNEL_NAME },
+            attributes: {
+                type: 'info',
+                action: button_action,
+                payload: payload
+            }
+        };
+    }
+
+    async _getMessage(callSid, ani, project_id, conversation_id, tdChannel) {
+        const startTime = Date.now();
+
+        // Use the passed tdChannel instead of creating a new one
+        // const tdChannel = new TiledeskChannel({ ... }) 
+        // tdChannel.setProjectId(project_id);
+
+        let message = {}, queue = []
+
+        try {
+            // 1. First attempt: read from queue
+            queue = await tdChannel.getMessagesFromQueue(conversation_id)
+            logger.debug('[getMessage] /NEXT check queue length--> ' + queue.length)
+
+            if (queue && queue.length > 0) {
+                message = queue[0]
+                logger.verbose('[getMessage] QUEUE --> ' + message.text)
+
+                await tdChannel.removeMessageFromQueue(conversation_id, message._id)
+                await this.voiceChannel.clearDelayTimeForCallId(callSid)
+
+                return message;
+            }
+
+            // 2. If queue is empty: subscribe with timeout
+            if (queue && queue.length === 0) {
+                logger.debug("[getMessage] Queue is empty, starting subscription...");
+
+                let timeoutId;
+
+                const subscriptionPromise = (async () => {
+                    await tdChannel.subscribeToTopic(conversation_id);
+                    queue = await tdChannel.getMessagesFromQueue(conversation_id)
+
+                    if (!queue || queue.length === 0) {
+                        throw new Error("No message received after subscription");
+                    }
+
+                    message = queue[0]
+                    logger.verbose(`[getMessage] Message received from subscription: ${message.text}`);
+
+                    await tdChannel.removeMessageFromQueue(conversation_id, message._id)
+                    await this.voiceChannel.clearDelayTimeForCallId(callSid)
+
+                    if (timeoutId) clearTimeout(timeoutId); // Clear timeout if subscription wins
+                    return message;
+                })();
+
+                const timeoutPromise = new Promise(async (resolve) => {
+                    timeoutId = setTimeout(async () => {
+                        logger.debug("[getMessage] Subscription timeout, generating waitTdMessage...");
+
+                        //CASE: queue is empty --> generate Tiledesk wait message and manage delayTime 
+                        const delayTime = await this.voiceChannel.getNextDelayTimeForCallId(callSid);
+                        const waitMessage = await tdChannel.generateWaitTdMessage(ani, delayTime);
+                        //update delayIndex for wait command message time
+                        await this.voiceChannel.saveDelayIndexForCallId(callSid);
+
+                        resolve(waitMessage);
+                    }, this.config.MAX_POLLING_TIME * 1000);
+                });
+
+                return await Promise.race([subscriptionPromise, timeoutPromise]);
+            }
+        } catch (err) {
+            logger.error("[getMessage] Error:", err);
+            throw err;
+        }
+    }
+}
+
+module.exports = VoiceController;