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

package/index.js

@@ -1,1531 +1,9 @@
-"use strict";
-const express = require("express");
-const bodyParser = require("body-parser")
-const router = express.Router();
-const winston = require("./winston");
-const fs = require("fs");
-const path = require('path');
-const pjson = require('./package.json');
-const axios = require("axios").default;
+const { startServer, app } = require('./src/app');
 
+// Export for use as npm package
+module.exports = { startServer, app };
 
-router.use(bodyParser.json()); // support json encoded bodies
-router.use(express.urlencoded({ extended: true })); // support encoded bodies
-router.use(express.static(path.join(__dirname, 'template')));
-
-//template
-const manageApp = require('./routes/manageApp');
-const manageRoute = manageApp.router;
-router.use('/manage', manageRoute);
-
-// tiledesk clients
-const { TiledeskChannel } = require("./tiledesk/TiledeskChannel");
-const { TiledeskTwilioTranslator } = require('./tiledesk/TiledeskTwilioTranslator');
-
-//services
-const { IntegrationService } = require('./tiledesk/services/IntegrationService');
-const { AiService } = require('./tiledesk/services/AiService')
-const { UploadService } = require('./tiledesk/services/UploadService')
-let integrationService = null;
-let aiService = null;
-let uploadService = null;
-
-//voice clients
-const { VoiceChannel } = require("./tiledesk/VoiceChannel");
-let voiceChannel = null;
-
-// mongo
-const { KVBaseMongo } = require('./tiledesk/KVBaseMongo');
-const kvbase_collection = 'kvstore';
-const db = new KVBaseMongo(kvbase_collection);
-
-// redis
-var redis = require('redis')
-var redis_client;
-
-//UTILS
-const CHANNEL_NAME = require('./tiledesk/constants').CHANNEL_NAME
-const CALL_STATUS = require('./tiledesk/constants').CALL_STATUS
-const VOICE_NAME = require('./tiledesk/constants').VOICE_NAME
-const VOICE_LANGUAGE = require('./tiledesk/constants').VOICE_LANGUAGE
-const OPENAI_SETTINGS = require('./tiledesk/constants').OPENAI_SETTINGS
-const VOICE_PROVIDER = require('./tiledesk/constants').VOICE_PROVIDER
-let BASE_POOLING_DELAY = require('./tiledesk/constants').BASE_POOLING_DELAY
-let MAX_POLLING_TIME = require('./tiledesk/constants').MAX_POLLING_TIME
-const utils = require('./tiledesk/utils.js')
-
-let API_URL = null;
-let BASE_URL = null;
-let BASE_FILE_URL = null;
-let OPENAI_ENDPOINT = null;
-let ELEVENLABS_ENDPOINT = null;
-let REDIS_HOST = null;
-let REDIS_PORT = null;
-let REDIS_PASSWORD = null;
-let BRAND_NAME = null;
-let GPT_KEY = null;
-
-let twilio = require('twilio');
-const VoiceResponse = require('twilio').twiml.VoiceResponse;
-const { MessagingResponse } = require('twilio').twiml;
-
-let start1= ''
-let time = null;
-
-/*UTILS*/
-const utilsMessage = require('./tiledesk/utils-message.js')
-const TYPE_MESSAGE = require('./tiledesk/constants').TYPE_MESSAGE
-
-let messageTimeout = null;
-
-router.get("/", async (req, res) => {
-  res.send("Welcome to Tiledesk-voice-twilio connector");
-});
-
-
-// TILEDESK WEBHOOK: message from tiledesk to user (chatbot/agent messagges)
-router.post("/tiledesk", async (req, res) => {
-  winston.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
-  
-  //const CONTENT_KEY = "voice-" + project_id;
-  //let settings = await db.get(CONTENT_KEY)
-  
-  const tdChannel = new TiledeskChannel({
-    API_URL: API_URL,
-    redis_client: redis_client
-  });
-  tdChannel.setProjectId(project_id)
-  
-  /*SKIP INFO MESSAGES*/
-  /*SKIP CURRENT USER MESSAGES*/
-  if(!utilsMessage.messageType(TYPE_MESSAGE.INFO, tiledeskMessage) && !(tiledeskMessage.sender.indexOf("vxml") > -1) ){
-    winston.verbose(`> whook SAVE MESSAGE "${tiledeskMessage.text}" TO QUEUE at time ` + new Date() );
-  }
-
-  await tdChannel.addMessageToQueue(tiledeskMessage)
-  
-  res.send("(voice) Message received from Voice Twilio Proxy");
-});
-
-// TWILIO WEBHOOK : message from user to tiledesk
-router.post('/webhook/:id_project', async (req, res) => {
-  let start_call = new Date().getTime();
-  winston.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){
-     return res.status(404).send({error: "Error: Missing from/to parameters"})
-  }
-  from = utils.getNumber(from); //remove '+' from number
-  to = utils.getNumber(to); //remove '+' from number
-  
-  const CONTENT_KEY = CHANNEL_NAME + "-" + project_id;
-  let settings = await 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
-  };
-  
-  const tdChannel = new TiledeskChannel({
-    API_URL: API_URL,
-    redis_client: redis_client,
-  });
-  tdChannel.setProjectId(project_id)
-  
-  const tdTranslator = new TiledeskTwilioTranslator({
-    BASE_URL: BASE_URL,
-    aiService: aiService,
-    uploadService: uploadService
-  });
-  
-  let start2 = new Date().getTime();
-  let user = await 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();
-  
-  //let conversation_id = await tdChannel.getConversation(ani, callId, user.token);
-  let conversation_id = await tdChannel.generateConversation(from, callSid, user.token);
-  winston.debug("(voice) conversation returned:"+ conversation_id);
-  
-  let integrations = [], publicKey = false;
-  try {
-    //GET AND SAVE GPT-KET IF 
-    let key = await integrationService.getKeyFromIntegrations(project_id, 'openai', settings.token)
-    if (!key) {
-        winston.debug("(voice) - Key not found in Integrations. Searching in kb settings...");
-        key = await integrationService.getKeyFromKbSettings(project_id, settings.token);
-    }
-    if (!key) {
-        winston.debug("(voice) - Retrieve public gptkey")
-        key = GPT_KEY;
-        publicKey = true;
-    }
-    integrations.push({type: 'openai', key: key, publicKey: publicKey})
-    
-    let eleven_labs = await integrationService.getKeyFromIntegrations(project_id, 'elevenlabs', settings.token)
-    if (eleven_labs) {
-        winston.debug("(voice) - Key found in Integrations: "+ eleven_labs);
-        integrations.push({type: 'elevenlabs', key: eleven_labs, publicKey: false})
-    }
-  } catch (error) {
-    winston.error('(voice) - Error retrieving integrations keys:', error);
-  }
-  
-  //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
-  }
-  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 tdChannel.send(tiledeskMessage, user.token, conversation_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 getMessage(callSid, from, project_id, conversation_id)
-  let end_time_get_message = new Date()
-  winston.verbose(`Time to getMessage from queue in /webhook/:${project_id} :  ${(end_time_get_message-start_time_get_message)}[ms] --- at time:` + new Date())
-  
-  // //generate Tiledesk wait message
-  // let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
-  // let waitTiledeskMessage = await tdChannel.generateWaitTdMessage(from, delayTime)
-  // //update delayIndex for wait command message time
-  // await voiceChannel.saveDelayIndexForCallId(from)
-  
-  // send standard wait vxml message
-  let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes, session_data) 
-  winston.debug('(voice) /webhook/:id_project messageVXML-->'+ messageToVXML)
-  
-  let end_call = new Date().getTime();
-  winston.info(`Time to respond to /webhook/${project_id}:  ${(end_call-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);
-});
-
-
-router.post('/nextblock_old/:callSid/', async(req, res) => {
-  let start_call = new Date()
-  winston.debug("(voice) called POST /nextblock ", req.body);
-  winston.debug("(voice) called POST /nextblock query ", req.query);
-  
-  let usertext = req.body.SpeechResult;
-  let confidence = req.body.Confidence
-  let callSid = req.params.callSid;
-  
-  let sessionInfo;
-  let project_id, conversation_id, user;
-  let from, to;
-
-  let redis_data = await voiceChannel.getSessionForCallId(callSid)
-  if (!redis_data) {
-    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
-  }
-  sessionInfo = JSON.parse(redis_data)
-  project_id = sessionInfo.project_id;
-  from = sessionInfo.from;
-  to = sessionInfo.to;
-  conversation_id = sessionInfo.conversation_id;
-  user = sessionInfo.user;
-  
-  let vxmlAttributes = {
-    TTS_VOICE_LANGUAGE: VOICE_LANGUAGE,
-    TTS_VOICE_NAME: VOICE_NAME,
-    callSid: callSid,
-  };
-  
-      
-  const tdChannel = new TiledeskChannel({
-    API_URL: API_URL,
-    redis_client: redis_client
-  })
-  tdChannel.setProjectId(project_id);
-
-  const tdTranslator = new TiledeskTwilioTranslator({
-    BASE_URL: BASE_URL,
-    aiService: aiService,
-    uploadService: uploadService
-  });
-    
-  
-  
-  let message = await new Promise(async (resolve, reject) => {
-    winston.debug('******* user text -->'+ usertext)
-    if(usertext === '' || !usertext){
-      
-      let message = await getMessage(callSid, from, project_id, conversation_id)
-      
-      resolve(message)
-    }else{
-      //CASE:usertext is not empty and queue is empty -->  send message to tiledesk and manage delayTime 
-      let tiledeskMessage= {
-        text:usertext,
-        senderFullname: from,
-        type: 'text',
-        channel: { name: CHANNEL_NAME }
-      };
-
-      let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
-      winston.debug("message sent : ", tdMessage);
-      //generate Tiledesk wait message
-      let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
-      let message = await tdChannel.generateWaitTdMessage(from, delayTime)
-      //update delayIndex for wait command message time
-      await voiceChannel.saveDelayIndexForCallId(callSid)
-      
-      resolve(message)
-    }
-  })
-  
-  
-  // convert response to vxml
-  let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
-  winston.debug("(voice) VXML to SEND: "+ messageToVXML);
-
-  let end_call = new Date()
-  console.log('Time to responde to /nextblock/:callSid : ', end_call-start_call, '[ms]')
-  
-  // Render the response as XML in reply to the webhook request
-  res.set('Content-Type', 'application/xml');
-  res.status(200).send(messageToVXML);
-  
-})
-
-router.post('/nextblock/:callSid/', async(req, res) => {
-  let start_call = new Date()
-  winston.verbose("(voice) called POST /nextblock at " + new Date() + "with text: "+ req.body.SpeechResult);
-  
-  let usertext = req.body.SpeechResult;
-  let confidence = req.body.Confidence
-  let callSid = req.params.callSid;
-  
-  let project_id, conversation_id, user;
-  let from, to;
-
-  let sessionInfo = await voiceChannel.getSessionForCallId(callSid)
-  if (!sessionInfo) {
-    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
-  }
-  project_id = sessionInfo.project_id;
-  from = sessionInfo.from;
-  to = sessionInfo.to;
-  conversation_id = sessionInfo.conversation_id;
-  user = sessionInfo.user;
-  
-  let vxmlAttributes = {
-    TTS_VOICE_LANGUAGE: VOICE_LANGUAGE,
-    TTS_VOICE_NAME: VOICE_NAME,
-    callSid: callSid,
-  };
-  
-      
-  const tdChannel = new TiledeskChannel({
-    API_URL: API_URL,
-    redis_client: redis_client
-  })
-  tdChannel.setProjectId(project_id);
-
-  const tdTranslator = new TiledeskTwilioTranslator({
-    BASE_URL: BASE_URL,
-    aiService: aiService,
-    uploadService: uploadService
-  });
-    
-  
-  let start_promise_message= new Date();
-  let message = await new Promise(async (resolve, reject) => {
-    winston.debug('(voice) ******* user text -->'+ usertext)
-    if(usertext === '' || !usertext){
-
-      let start_time_get_message = new Date()
-      let message = await getMessage(callSid, from, project_id, conversation_id)
-      let end_time_get_message = new Date()
-      winston.verbose(`(if) Time to getMessage from queue in /nextblock/${callSid} : ${(end_time_get_message-start_time_get_message)}[ms]`)
-      resolve(message)
-    }else{
-      //CASE:usertext is not empty and queue is empty -->  send message to tiledesk and manage delayTime 
-      let tiledeskMessage= {
-        text:usertext,
-        senderFullname: from,
-        type: 'text',
-        channel: { name: CHANNEL_NAME }
-      };
-
-      let start_time_send_message = new Date()
-      let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
-      let end_time_send_message = new Date()
-      winston.verbose(`(else) Time to send message to tiledesk in /nextblock/${callSid} : ${(end_time_send_message-start_time_send_message)}[ms] with text ` + tdMessage.text + ' --- at time:' + new Date())
-     
-      let start_time_get_message = new Date()
-      let message = await getMessage(callSid, from, project_id, conversation_id)
-      let end_time_get_message = new Date()
-      winston.verbose(`(else) Time to getMessage from queue in /nextblock/${callSid} : ${(end_time_get_message-start_time_get_message)}[ms]` + ' --- at time:' + new Date())
-      resolve(message)
-      
-      //generate Tiledesk wait message
-      // let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
-      // let message = await tdChannel.generateWaitTdMessage(from, delayTime)
-      // //update delayIndex for wait command message time
-      // await voiceChannel.saveDelayIndexForCallId(callSid)
-      // resolve(message)
-    }
-  })
-  let end_promise_message = new Date()
-  winston.verbose(`Time to manage message in Promise /nextblock/${callSid}: ${(end_promise_message-start_promise_message)}[ms]` + ' with text:' + message.text + ' --- at time --' + new Date())  
-  
-  // convert response to vxml
-  let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
-  winston.debug("(voice) VXML to SEND: "+ messageToVXML);
-
-  let end_call = new Date()
-  winston.info(`Time to respond to /nextblock/${callSid} :  ${(end_call-start_call)} [ms]`)
-  
-  // Render the response as XML in reply to the webhook request
-  res.set('Content-Type', 'application/xml');
-  res.status(200).send(messageToVXML);
-  
-})
-
-async function getMessage(callSid, ani, project_id, conversation_id){
-  const startTime = Date.now();
-  
-  const tdChannel = new TiledeskChannel({
-    API_URL: API_URL,
-    redis_client: redis_client
-  })
-  tdChannel.setProjectId(project_id);
-  
-  let message = {}, queue = []
-  
-  //get queue
-  //if queue exist and has at least one message
-    //get message from queue, remove it from queue and clear delayTime
-  //else
-    //subscribe to topic
-    //create promise that resolve after MAX_POLLING_TIME s
-    //race between subscription and timeout and return a message
-    //if subscription resolve first and queue has at least one message
-      //get message from queue, remove it from queue and clear delayTime
-
-    try{
-
-      // 1. First attempt: read from queue
-      queue = await tdChannel.getMessagesFromQueue(conversation_id)
-      winston.debug('[getMessage] /NEXT check queue length--> '+ queue.length)
-
-      if (queue && queue.length > 0) {
-        //CASE: queue has at least one message to reproduce --> get message from tiledesk queue and reset delayTime
-        message = queue[0]
-        winston.verbose('[getMessage] QUEUE --> '+ queue[0].text)
-
-        // remove message from queue and reset delayIndex
-        await tdChannel.removeMessageFromQueue(conversation_id, message._id)
-        await voiceChannel.clearDelayTimeForCallId(callSid)
-
-        return message;
-      }
-
-      // 2. If queue is empty: subscribe with timeout
-      if(queue && queue.length === 0){
-        winston.debug("[getMessage] Queue is empty, starting subscription...");
-        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]
-          winston.verbose(`[getMessage] Message received from subscription: ${message.text}`);
-
-          // remove message from queue and reset delayIndex
-          await tdChannel.removeMessageFromQueue(conversation_id, message._id)
-          await voiceChannel.clearDelayTimeForCallId(callSid)
-
-          return message;
-        })();
-
-        const timeoutPromise = new Promise(async (resolve) => {
-          setTimeout(async () => {
-            winston.debug("[getMessage] Subscription timeout, generating waitTdMessage...");
-
-            //CASE: queue is empty --> generate Tiledesk wait message and manage delayTime 
-            const delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid);
-            const waitMessage = await tdChannel.generateWaitTdMessage(ani, delayTime);
-            //update delayIndex for wait command message time
-            await voiceChannel.saveDelayIndexForCallId(callSid);
-
-            resolve(waitMessage);
-          }, MAX_POLLING_TIME * 1000); // MAX_POLLING_TIME is in seconds
-        });
-
-        // Vince chi arriva prima: subscription o timeout
-        return await Promise.race([subscriptionPromise, timeoutPromise]);
-      }
-    }catch(err){
-      winston.debug("[getMessage] Error occurred: ", err);
-      reject(err);
-      return;
-    }
-    
-}
-
-router.post('/speechresult/:callSid', async (req, res) => {
-  let start_call = new Date();
-  winston.verbose("(voice) called POST /speechresult at" + new Date() + "with text: "+ req.body.SpeechResult);
-  
-  let usertext = req.body.SpeechResult;
-  let confidence = req.body.Confidence
-  let callSid = req.params.callSid;
-  
-  let project_id, conversation_id, user;
-  let from, to;
-
-  let sessionInfo = await voiceChannel.getSessionForCallId(callSid)
-  if (!sessionInfo) {
-    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
-  }
-  project_id = sessionInfo.project_id;
-  from = sessionInfo.from;
-  to = sessionInfo.to;
-  conversation_id = sessionInfo.conversation_id;
-  user = sessionInfo.user;
-  
-  let vxmlAttributes = {
-    TTS_VOICE_LANGUAGE: VOICE_LANGUAGE,
-    TTS_VOICE_NAME: VOICE_NAME,
-    callSid: callSid,
-  };
-      
-  const tdChannel = new TiledeskChannel({
-    API_URL: API_URL,
-    redis_client: redis_client
-  })
-  tdChannel.setProjectId(project_id);
-
-  const tdTranslator = new TiledeskTwilioTranslator({
-    BASE_URL: BASE_URL,
-    aiService: aiService,
-    uploadService: uploadService
-  });
-  
-  
-  let start_promise_message= new Date();
-  let message = await new Promise(async (resolve, reject) => {
-    winston.debug('(voice) ******* user text -->'+ usertext)
-    if(usertext === '' || !usertext){
-
-      let start_time_get_message = new Date()
-      let message = await getMessage(callSid, from, project_id, conversation_id)
-      let end_time_get_message = new Date()
-      winston.verbose(`(if) Time to getMessage from queue in /speechresult/${callSid} : ${(end_time_get_message-start_time_get_message)}[ms]`)
-      resolve(message)
-    }else{
-      //CASE:usertext is not empty and queue is empty -->  send message to tiledesk and manage delayTime 
-      let tiledeskMessage= {
-        text:usertext,
-        senderFullname: from,
-        type: 'text',
-        channel: { name: CHANNEL_NAME }
-      };
-
-      let start_time_send_message = new Date()
-      let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
-      let end_time_send_message = new Date()
-      winston.debug("message sent : ", tdMessage);
-      winston.verbose(`(else) Time to send message to tiledesk in /speechresult/${callSid} : ${(end_time_send_message-start_time_send_message)}[ms] with text ` + tdMessage.text + ' --- at time:' + new Date())
-     
-      let start_time_get_message = new Date()
-      let message = await getMessage(callSid, from, project_id, conversation_id)
-      let end_time_get_message = new Date()
-      winston.verbose(`(else) Time to getMessage from queue in /speechresult/${callSid} : ${(end_time_get_message-start_time_get_message)}[ms]` + ' --- at time:' + new Date())
-      resolve(message)
-      
-      //generate Tiledesk wait message
-      // let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
-      // let message = await tdChannel.generateWaitTdMessage(from, delayTime)
-      // //update delayIndex for wait command message time
-      // await voiceChannel.saveDelayIndexForCallId(callSid)
-      // resolve(message)
-    }
-  });
-  let end_promise_message = new Date()
-  winston.verbose(`Time to manage message in Promise /speechresult/${callSid}: ${(end_promise_message-start_promise_message)}[ms]` + ' with text' + message.text + ' --- at time --' + new Date())  
-
-  // convert response to vxml
-  let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
-  winston.debug("(voice) VXML to SEND: "+ messageToVXML);
-  
-  let end_call = new Date()
-  winston.info(`Time to respond to /speechresult/${callSid} :  ${(end_call-start_call)} [ms]`)
-  
-  // Render the response as XML in reply to the webhook request
-  res.set('Content-Type', 'application/xml');
-  res.status(200).send(messageToVXML);
-})
-
-/* ----> called with Record tag in action property <----- */
-router.post('/record/action/:callSid/',async (req, res) => {
-  winston.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;
-  let project_id, conversation_id, user;
-  let from, to;
-
-  let sessionInfo = await voiceChannel.getSessionForCallId(callSid)
-  if (!sessionInfo) {
-    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
-  }
-  project_id = sessionInfo.project_id;
-  from = sessionInfo.from;
-  to = sessionInfo.to;
-  conversation_id = sessionInfo.conversation_id;
-  user = sessionInfo.user;
-  
-  let vxmlAttributes = {
-    TTS_VOICE_LANGUAGE: VOICE_LANGUAGE,
-    TTS_VOICE_NAME: VOICE_NAME,
-    callSid: callSid,
-  };
-
-  const tdChannel = new TiledeskChannel({
-    API_URL: API_URL,
-    redis_client: redis_client
-  })
-  tdChannel.setProjectId(project_id)
-
-  const tdTranslator = new TiledeskTwilioTranslator({
-    BASE_URL: BASE_URL,
-    aiService: aiService,
-    uploadService: uploadService
-  });
-
-
-  let start_time_get_message = new Date()
-  let message = await getMessage(callSid, from, project_id, conversation_id)
-  winston.debug('message from getMessage in /record/action/: ', message)
-  let end_time_get_message = new Date()
-  winston.verbose(`Time to getMessage from queue in /record/action/${callSid} : ${(end_time_get_message-start_time_get_message)}[ms]` + ' --- at time:' + new Date())
-   
-
-  //generate Tiledesk wait message
-  // let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
-  // let message = await tdChannel.generateWaitTdMessage(from, delayTime)
-  // //update delayIndex for wait command message time
-  // await voiceChannel.saveDelayIndexForCallId(callSid)
-
-  // convert response to vxml
-  let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
-  winston.debug("(voice) /record/action VXML to SEND: "+ messageToVXML);
-  
-  let end_call = new Date();
-  winston.info(`Time to respond to /record/action/${callSid} :  ${(end_call-start_call)}[ms]`)
-  res.set('Content-Type', 'application/xml');
-  res.status(200).send(messageToVXML);
-
-});
-
-/* ----> called with Record tag in recordingStatusCallback property <----- */
-router.post('/record/callback/:callSid/',async (req, res) => {
-  winston.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 audioFileDuration = req.body.RecordingDuration;
-  let button_action = req.query.button_action ? '#' + req.query.button_action : '';
-  let previousIntentName = req.query.intentName || '';
-
-  let project_id, conversation_id, user;
-  let from, to;
-  
-  let sessionInfo = await voiceChannel.getSessionForCallId(callSid)
-  if (!sessionInfo) {
-    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
-  }
-  project_id = sessionInfo.project_id;
-  from = sessionInfo.from;
-  to = sessionInfo.to;
-  conversation_id = sessionInfo.conversation_id;
-  user = sessionInfo.user;
-  
-  const tdChannel = new TiledeskChannel({
-    API_URL: API_URL,
-    redis_client: redis_client
-  })
-  tdChannel.setProjectId(project_id)
-  
-  const CONTENT_KEY = CHANNEL_NAME + "-" + project_id;
-  let settings = await db.get(CONTENT_KEY);
-  if(!settings){
-    return res.status(404).send({error: "VOICE Channel not already connected"})
-  }
-  
-  let tiledeskMessage = null;
-  // tiledeskMessage = buildNoInputMessage('no_input', { from, button_action, payload: { event: 'no_input',  lastBlock: previousIntentName, lastTimestamp: Date.now()} });
-  
-  //SPEECH TO TEXT
-  const attributes = await voiceChannel.getSettingsForCallId(callSid);
-  winston.debug(`[VOICE] getting text message from STT: ${audioFileUrl}, model: ${attributes.STT_MODEL}`);
-  // generateSTT ritorna sempre un oggetto coerente (anche vuoto o /close)
-  tiledeskMessage = await generateSTT(audioFileUrl, attributes, sessionInfo, settings)
-  winston.debug('[VOICE] tiledeskMessage from STT: ', tiledeskMessage)
-  if (!tiledeskMessage || Object.keys(tiledeskMessage).length === 0) {
-    winston.debug(`[VOICE] STT result empty, fallback to no_input branch for callSid ${callSid}`);
-    tiledeskMessage = buildNoInputMessage('no_input', { from, button_action, payload: { event: 'no_input',  lastBlock: previousIntentName, lastTimestamp: Date.now()} });
-  }else {
-    const normalizedText = utils.normalizeSTT(tiledeskMessage.text);
-    winston.verbose(`[VOICE] normalized STT text: ${normalizedText} for callSid ${callSid}`);
-    if(!normalizedText){
-      tiledeskMessage = 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 tdChannel.send(tiledeskMessage, user.token, conversation_id);
-  let end_call = new Date();
-  winston.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});
-})
-
-
-router.post('/menublock/:callSid', async (req, res) => {
-  let start_call = new Date().getTime();
-  winston.debug("(voice) called POST /menu", req.body);
-  winston.debug("(voice) called POST /menu query" , req.query);
-  winston.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 previousIntentName = req.query.intentName;
-  
-  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
-  }
-  
-  winston.debug("(voice) button menu: ", button);
-  winston.debug("(voice) message_text menu: "+ message_text);
-  
-  let project_id, conversation_id, user;
-  let from, to;
-
-  let sessionInfo = await voiceChannel.getSessionForCallId(callSid)
-  if (!sessionInfo) {
-    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
-  }
-  project_id = sessionInfo.project_id;
-  from = sessionInfo.from;
-  to = sessionInfo.to;
-  conversation_id = sessionInfo.conversation_id;
-  user = sessionInfo.user;
-
-  let vxmlAttributes = {
-    TTS_VOICE_LANGUAGE: VOICE_LANGUAGE,
-    TTS_VOICE_NAME: VOICE_NAME,
-    callSid: callSid,
-  };
-
-  const tdChannel = new TiledeskChannel({
-    API_URL: API_URL,
-    redis_client: redis_client
-  })
-  tdChannel.setProjectId(project_id);
-
-  const tdTranslator = new TiledeskTwilioTranslator({
-    BASE_URL: BASE_URL,
-    aiService: aiService,
-    uploadService: uploadService
-  });
-  
-  //send message to tiledesk 
-  let tiledeskMessage= {
-    text:message_text,
-    senderFullname: from,
-    type: 'text',
-    channel: { name: CHANNEL_NAME },
-    attributes: attributes
-  };
-  let response = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
-  if(!response){
-    return res.status(503).send({ message: "Bad response: Quota exceeded" })
-  }
-
-  let start_time_get_message = new Date()
-  let message = await getMessage(callSid, from, project_id, conversation_id)
-  let end_time_get_message = new Date()
-  winston.verbose(`Time to getMessage from queue in /menublock/${callSid} : ${(end_time_get_message-start_time_get_message)}[ms]` + ' --- at time:' + new Date())
-      
-  // //generate Tiledesk wait message
-  // let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
-  // let message = await tdChannel.generateWaitTdMessage(from, delayTime)    
-  // //update delayIndex for wait command message time
-  // await voiceChannel.saveDelayIndexForCallId(callSid)
-
-  // convert response to vxml
-  let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
-  winston.debug("(voice) VXML to SEND: "+ messageToVXML);
-  
-  let end_call = new Date().getTime();
-  winston.info(`Time to respond to /menublock/${callSid} :  ${(end_call-start_call)} [ms]`)
-  
-  res.set('Content-Type', 'application/xml');
-  res.status(200).send(messageToVXML);
-});
-
-router.post('/handle/:callSid/:event', async (req, res) => {
-  winston.debug("(voice) called POST /handle", req.body);
-  winston.debug("(voice) called POST /handle query -->", req.query);
-  winston.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;
-  
-  let project_id, conversation_id, user;
-  let from, to;
-
-  let sessionInfo = await voiceChannel.getSessionForCallId(callSid)
-  if (!sessionInfo) {
-    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
-  }
-  project_id = sessionInfo.project_id;
-  from = sessionInfo.from;
-  to = sessionInfo.to;
-  conversation_id = sessionInfo.conversation_id;
-  user = sessionInfo.user;
-  
-  let vxmlAttributes = {
-    TTS_VOICE_LANGUAGE: VOICE_LANGUAGE,
-    TTS_VOICE_NAME: VOICE_NAME,
-    callSid: callSid,
-  };
-
-  const tdChannel = new TiledeskChannel({
-    API_URL: API_URL,
-    redis_client: redis_client
-  })
-  tdChannel.setProjectId(project_id);
-
-  const tdTranslator = new TiledeskTwilioTranslator({
-    BASE_URL: BASE_URL,
-    aiService: aiService,
-    uploadService: uploadService
-  });
-  
-
-  //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 tdChannel.send(tiledeskMessage, user.token, conversation_id);
-
-  //generate Tiledesk wait message
-  let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
-  let message = await tdChannel.generateWaitTdMessage(callSid, delayTime) 
-  ///update delayIndex for wait command message time
-  await voiceChannel.saveDelayIndexForCallId(callSid)
-
-  // convert response to vxml
-  let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes,sessionInfo)
-  winston.debug("(voice) VXML to SEND: "+ messageToVXML);
-  
-  res.set('Content-Type', 'application/xml');
-  res.status(200).send(messageToVXML);
-  
-});
-
-
-/* ----> catch Event block <----- */
-router.post('/event/:callSid/:event', async(req, res)=> {
-  winston.debug("(voice) called POST /event" , req.params);
-  winston.debug("(voice) called POST /event query" , req.query);
-  winston.debug("(voice) called POST /event body" , req.body);
-  
-  //clear getMessage function timeout
-  if(messageTimeout){
-    clearTimeout(messageTimeout)
-  }
-  
-  let event = req.params.event;
-  let callSid = req.params.callSid;
-  let currentIntentName = req.query.intentName;
-  let currentIntentTimestamp  = req.query.previousIntentTimestamp;
-  
-  let project_id, conversation_id, user;
-  let from, to;
-  
-  let sessionInfo = await voiceChannel.getSessionForCallId(callSid)
-  if (!sessionInfo) {
-    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
-  }
-  project_id = sessionInfo.project_id;
-  from = sessionInfo.from;
-  to = sessionInfo.to;
-  conversation_id = sessionInfo.conversation_id;
-  user = sessionInfo.user;
-  
-  let vxmlAttributes = {
-    TTS_VOICE_LANGUAGE: VOICE_LANGUAGE,
-    TTS_VOICE_NAME: VOICE_NAME,
-    callSid: callSid,
-  };
-
-  const tdChannel = new TiledeskChannel({
-    API_URL: API_URL,
-    redis_client: redis_client
-  })
-  tdChannel.setProjectId(project_id);
-
-  const tdTranslator = new TiledeskTwilioTranslator({
-    BASE_URL: BASE_URL,
-    aiService: aiService,
-    uploadService: uploadService
-  });
-  
-  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 tdChannel.send(tiledeskMessage, user.token, conversation_id);
-        }
-    }
-    
-  }
-  
-  
-  //generate Tiledesk wait message
-  let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
-  let message = await tdChannel.generateWaitTdMessage(callSid, delayTime) 
-  ///update delayIndex for wait command message time
-  await voiceChannel.saveDelayIndexForCallId(callSid)
-
-  // convert response to vxml
-  let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
-  winston.debug("(voice) VXML to SEND: "+ messageToVXML);
-  
-  res.set('Content-Type', 'application/xml');
-  res.status(200).send(messageToVXML);
-})
-
-
-/* ----> catch Twilio Events <----- */
-router.post('/twilio/status',async (req, res) => {
-  winston.debug('+++++++++++(voice) called POST twilio/status ', req.body);
-  
-  let event = req.body.CallStatus;
-  let callSid = req.body.CallSid;
-  
-  //clear getMessage function timeout
-  if(messageTimeout){
-    clearTimeout(messageTimeout)
-  }
-  
-  let project_id, conversation_id, user;
-  let from, to;
-  
-  let sessionInfo = await voiceChannel.getSessionForCallId(callSid)
-  if (!sessionInfo) {
-    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
-  }
-  project_id = sessionInfo.project_id;
-  from = sessionInfo.from;
-  to = sessionInfo.to;
-  conversation_id = sessionInfo.conversation_id;
-  user = sessionInfo.user;
-  
-  let vxmlAttributes = {
-    TTS_VOICE_LANGUAGE: VOICE_LANGUAGE,
-    TTS_VOICE_NAME: VOICE_NAME,
-    callSid: callSid,
-  };
-  
-  const tdChannel = new TiledeskChannel({
-    API_URL: API_URL,
-    redis_client: redis_client
-  })
-  tdChannel.setProjectId(project_id)
-
-  const tdTranslator = new TiledeskTwilioTranslator({
-    BASE_URL: BASE_URL,
-    aiService: aiService,
-    uploadService: uploadService
-  });
-  
-  
-  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 tdChannel.send(tiledeskMessage, user.token, conversation_id);
-
-      //remove session data for current callId and relative queue data
-      await voiceChannel.deleteCallKeys(callSid);
-      await tdChannel.clearQueue(conversation_id);
-      break;
-    }
-  }
-  
-   res.status(200).send();
-
-})
-
-
-
-router.post('/twilio/fail',async (req, res) => {
-  winston.debug('+++++++++++(voice) called POST twilio/fail ', req.params)
-  winston.debug('+++++++++++(voice) called POST twilio/fail ', req.body)
-
-  res.set('Content-Type', 'application/xml');
-  res.status(200).send('<Response></Response>');
-})
-
-
-
-async function generateSTT(audioFileUrl, attributes, sessionInfo, settings){
-    
-  winston.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 aiService.checkQuoteAvailability(sessionInfo.project_id, settings.token)
-          winston.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 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 aiService.speechToTextElevenLabs( audioFileUrl, attributes.STT_MODEL, ttsLanguage, ELEVENLABS_APIKEY )
-        break;
-      }
-      default:
-        throw new Error('Unsupported VOICE_PROVIDER: ' + attributes.VOICE_PROVIDER);
-    }
-
-    if(text){
-      winston.debug('[STT] text empty → fallback no_input');
-      tiledeskMessage = {
-        text: text,
-        senderFullname: sessionInfo.from,
-        type: 'text',
-        channel: { name: CHANNEL_NAME }
-      };
-    }
-  } catch (error) {
-    winston.error('[STT] generateSTT error:', error);
-    switch (error.code) {
-      case 'AISERVICE_FAILED':
-        winston.error('[STT] AISERVICE_FAILED → ', error.message);
-        break;
-    }
-
-    // fallback: tiledeskMessage vuoto
-    tiledeskMessage = {};
-    
-  }
-
-  return tiledeskMessage
-}
-
-
-async function 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
-    }
-  };
-}
-
-
-
-router.get('/addon/transcript', async (req, res) => {
-  winston.debug("(voice) called GET /transcript query-->" , req.query);
-  winston.debug("(voice) called GET /transcript body -->" , req.body);
-  
-  res.status(200).send('ok');
-  
-});
-
-/**   --> only for test purpose <--   **/
-router.get('/test', async (req, res) => {
-  winston.debug("(voice) called GET /test" , req.query);
-  
-  let project_id = req.query.id_project;
-  let callSid = req.body.CallSid;
-  let from = req.body.From;
-  let to = req.body.To;
-  
-  if(!from || !to){
-     return res.status(404).send({error: "Error: Missing from/to parameters"})
-  }
-  from = utils.getNumber(from); //remove '+' from number
-  to = utils.getNumber(to); //remove '+' from number
-  
-  const tdChannel = new TiledeskChannel({
-    API_URL: API_URL,
-    redis_client: redis_client,
-  });
-  tdChannel.setProjectId(project_id)
-  
-  const tdTranslator = new TiledeskTwilioTranslator({
-    BASE_URL: BASE_URL,
-    aiService: aiService,
-    uploadService: uploadService
-  });
-  
-  //let result = await tdChannel.signIn(ani)
-  
-  //let conversation_id = await tdChannel.getConversation(ani, callId, result.token);
-  //let message = await tdChannel.sendMessageAndWait(ani, result.chat21.user_data, conversation_id, '/start');
-  let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid);
-  let waitTiledeskMessage = await tdChannel.generateWaitTdMessage(from, delayTime);
-  
-  //console.log("response message: ", message);
-  let message2= {
-    attributes: {
-      commands: [
-        {
-          type: 'wait',
-          time: 500
-        },
-        {
-          type: 'message',
-          message: {
-            text: 'ciao',
-          }
-        }
-      ]
-    }
-  }
-  
-  let message_buttons = {
-    attributes: {
-      disableInputMessage: true,
-      commands: [
-        {
-          type: 'wait',
-          time: 500
-        },
-        {
-          type: 'message',
-          message: {
-            text: 'ciao',
-            type: 'text',
-            attributes: {
-              attachment: {
-                buttons: [
-                  {value: 'button1', type: 'action', target: 'blank', action: '#action1'},
-                  {value: 'button2', type: 'action', target: 'blank', action: '#action2'}
-                ]
-              }
-            }
-          }
-        },
-        {
-          type: 'wait',
-          time: 500
-        },
-        {
-          type: 'message',
-          message: {
-            text: 'ciao 2',
-            type: 'frame',
-            metadata: {
-              src:"https://your-audio-url.com"
-            }
-          }
-        },
-        {
-          type: 'wait',
-          time: 0
-        },
-        /*{
-          type: 'settings',
-          subType: 'blind_transfer',
-          settings: {
-            transferTo: "6040",
-            transferType: "consultation",
-            falseIntent: "#falseIntenttt",
-            trueIntent: "#trueIntennt"
-          }
-        }*/
-        /*{
-          type: 'settings',
-          subType: 'dtmf_form',
-          settings: {
-            minDigits: 5,
-            maxDigits: 5,
-            terminators: "#",
-            noInputIntent: "#a",
-            noInputTimeout: 2000,
-          }
-        }*/
-        {
-          type: 'settings',
-          subType: 'speech_form',
-          settings: {
-            noInputIntent: "#a",
-            noInputTimeout: 2000,
-          }
-        }
-      ]
-    }
-  }
-
-  
-  let vxmlAttributes = {
-    TTS_VOICE_LANGUAGE: VOICE_LANGUAGE,
-    TTS_VOICE_NAME: VOICE_NAME,
-    callSid: callSid
-  };
-  
-  let sessionInfo = {
-    user: {
-      _id: 'id_user'
-    },
-    integrations: [
-      { type: 'openai', key: GPT_KEY}
-    ]
-  }
-  
-  
-  // convert response to vxml
-  let messageToVXML = await tdTranslator.toVXML(message_buttons, callSid, vxmlAttributes, sessionInfo )
-  //let disconnect = await tdChannel.disconnect();
-  
-  
-  res.set('Content-Type', 'application/xml');
-  res.status(200).send(messageToVXML);
-  
-  //res.status(200).send(message);
-  
-})
-
-
-async function connectRedis() {
-  /*redis_client = await redis.createClient({
-    host: REDIS_HOST,
-    port: REDIS_PORT,
-    password: REDIS_PASSWORD
-  });*/
-  
-  if(REDIS_PASSWORD){
-    redis_client = await redis.createClient({
-      socket: {
-        host: REDIS_HOST,
-        port: REDIS_PORT
-      },
-      password: REDIS_PASSWORD,
-    })
-  }else {
-    redis_client = await redis.createClient({
-      url: 'redis://'+REDIS_HOST+':'+REDIS_PORT
-    })
-  }
-  
-  
-  redis_client.on('error', err => {
-    winston.error('(voice) Connect Redis Error ' + err);
-  })
-  /*
-  redis_client.on('connect', () => {
-    winston.debug('Redis Connected!'); // Connected!
-  });
-  */
-  redis_client.on('ready', () => {
-    winston.debug("(voice) Redis ready!")
-  })
-  await redis_client.connect(); // only for v4
-  require('bluebird').promisifyAll(redis_client)
-
-}
-
-async function startApp(settings, callback) {
-  winston.info("(voice) Starting VOICE TWILIO App");
-  
-  if (!settings.MONGODB_URI) {
-    winston.error("(voice) MONGODB_URI is mandatory. Exit...");
-    return callback('Missing parameter: MONGODB_URI');
-  }
-  
-  if (!settings.API_URL) {
-    let port = process.env.PORT || 3000;
-    API_URL = 'http://localhost:' + port;
-  } else {
-    API_URL = settings.API_URL;
-  }
-  winston.debug("(voice) API_URL: " + API_URL)
-  
-  if (!settings.BASE_FILE_URL) {
-    let port = process.env.PORT || 3000;
-    BASE_FILE_URL = 'http://localhost:' + port;
-  } else {
-    BASE_FILE_URL = settings.BASE_FILE_URL;
-  }
-  winston.debug("(voice) API_URL: " + API_URL)
-  
-  if (!settings.BASE_URL) {
-    winston.error("(voice) BASE_URL is mandatory. Exit...");
-    return callback('Missing parameter: BASE_URL');
-  } else {
-    BASE_URL = settings.BASE_URL;
-    winston.debug("(voice) BASE_URL: " + BASE_URL);
-  }
-  
-  if (settings.BRAND_NAME) {
-    BRAND_NAME = settings.BRAND_NAME
-  }
-  
-  if (settings.GPT_KEY) {
-    GPT_KEY = settings.GPT_KEY;
-  }
-  
-  if(settings.OPENAI_ENDPOINT){
-    OPENAI_ENDPOINT = settings.OPENAI_ENDPOINT
-  }
-  if(settings.ELEVENLABS_ENDPOINT){
-    ELEVENLABS_ENDPOINT = settings.ELEVENLABS_ENDPOINT
-  }
-  
-  if(settings.MAX_POLLING_TIME){
-    MAX_POLLING_TIME = settings.MAX_POLLING_TIME/1000; //convert in seconds
-  }
-  
-  if (settings.REDIS_HOST && settings.REDIS_PORT) {
-    REDIS_HOST = settings.REDIS_HOST;
-    REDIS_PORT = settings.REDIS_PORT;
-    REDIS_PASSWORD = settings.REDIS_PASSWORD;
-    await connectRedis();
-  } else {
-    winston.error("(voice) Missing redis parameters --> REDIS_HOST and REDIS_PORT");
-  }
-  
-  //init VOICE CHANNEL
-  voiceChannel = new VoiceChannel({
-    BASE_POOLING_DELAY: settings.BASE_POOLING_DELAY || BASE_POOLING_DELAY,
-    redis_client: redis_client,
-  })
-  
-  //init Services
-  aiService = new AiService({
-    OPENAI_ENDPOINT: OPENAI_ENDPOINT,
-    ELEVENLABS_ENDPOINT: ELEVENLABS_ENDPOINT,
-    API_URL: API_URL
-  })
-  integrationService = new IntegrationService({
-     API_URL: API_URL,
-  })
-  uploadService = new UploadService({
-    API_URL: BASE_FILE_URL,
-  })
-  
-  
-  if (settings.dbconnection) {
-    db.reuseConnection(settings.dbconnection, () => {
-      winston.debug("(voice) KVBaseMongo reused exsisting db connection");
-      if (callback) {
-        callback(null);
-      }
-    })
-  } else {
-    db.connect(settings.MONGODB_URI, () => {
-      winston.debug("(voice) KVBaseMongo successfully connected.");
-  
-      if (callback) {
-        callback(null);
-      }
-    });
-  }
-  
-  manageApp.startApp({
-    API_URL: API_URL,
-    BASE_URL: BASE_URL,
-    BRAND_NAME: BRAND_NAME,
-    DB: db,
-    redis_client: redis_client
-  }, (err) => {
-    if (!err) {
-      winston.info("Manage route succesfully started.");
-    } else {
-      winston.error("(voice) Unable to start API route.")
-    }
-  })
-  
-}
-
-function readHTMLFile(templateName, callback) {
-  fs.readFile(__dirname + '/template' + templateName, { encoding: 'utf-8' },
-    function(err, html) {
-      if (err) {
-        throw err;
-        //callback(err);
-      } else {
-        callback(null, html)
-      }
-    })
-}
-
-module.exports = { router: router, startApp: startApp };
+// Auto-start server when run directly (standalone mode)
+if (require.main === module) {
+  startServer();
+}