@tiledesk/tiledesk-voice-twilio-connector 0.1.26-rc8 → 0.1.26

package/index.js

@@ -73,7 +73,7 @@ let start1= ''
 let time = null;
 
 /*UTILS*/
-const utilsMess = require('./tiledesk/utils-message.js')
+const utilsMessage = require('./tiledesk/utils-message.js')
 const TYPE_MESSAGE = require('./tiledesk/constants').TYPE_MESSAGE
 
 let messageTimeout = null;
@@ -100,24 +100,19 @@ router.post("/tiledesk", async (req, res) => {
   
   /*SKIP INFO MESSAGES*/
   /*SKIP CURRENT USER MESSAGES*/
-  if(!utilsMess.messageType(TYPE_MESSAGE.INFO, tiledeskMessage) && !(tiledeskMessage.sender.indexOf("vxml") > -1) ){
-    winston.verbose("> whook SAVE MESSAGE TO QUEUE " + JSON.stringify(tiledeskMessage) );
-    start1 = new Date().getTime();
-    console.log("(WH) time: ", new Date().getTime() - time)
-    console.log("(WH) received message: ", tiledeskMessage.text, ' --- at time:', new Date(), start1)
+  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) => {
-  winston.debug('(voice) called POST /webhook/:id_project '+ new Date(), req.params)
   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;
@@ -137,6 +132,8 @@ router.post('/webhook/:id_project', async (req, res) => {
   }
   
   let vxmlAttributes = {
+    TTS_VOICE_LANGUAGE: VOICE_LANGUAGE,
+    TTS_VOICE_NAME: VOICE_NAME,
     callSid: callSid
   };
   
@@ -148,7 +145,8 @@ router.post('/webhook/:id_project', async (req, res) => {
   
   const tdTranslator = new TiledeskTwilioTranslator({
     BASE_URL: BASE_URL,
-    aiService: aiService
+    aiService: aiService,
+    uploadService: uploadService
   });
   
   let start2 = new Date().getTime();
@@ -158,32 +156,33 @@ router.post('/webhook/:id_project', async (req, res) => {
     return;
   }
   let end2 = new Date().getTime();
-  console.log('Time after signIn: ', end2-start2, '[ms]')
   
   //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);
   
-  
-  //GET AND SAVE GPT-KET IF 
   let integrations = [], publicKey = false;
-  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;
+  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})
     
-  }
-  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})
+    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
@@ -229,7 +228,7 @@ router.post('/webhook/:id_project', async (req, res) => {
   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 /:project_id/start : ' + end_time_get_message-start_time_get_message + '[ms] --- at time:' + 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)
@@ -238,17 +237,15 @@ router.post('/webhook/:id_project', async (req, res) => {
   // await voiceChannel.saveDelayIndexForCallId(from)
   
   // send standard wait vxml message
-  let messageToVXML = await tdTranslator.toVXML(waitTiledeskMessage, callSid, vxmlAttributes, session_data) 
-  winston.debug('(voice) messageVXML-->'+ messageToVXML)
+  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);
-  
-  let end_call = new Date().getTime();
-  console.log('Time to responde to /webhook/:id_project : ', end_call-start_call, '[ms]')
-  
 });
 
 
@@ -256,7 +253,6 @@ 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);
-  console.log('/nextblock at: ', new Date(), 'with text:', req.body.SpeechResult)
   
   let usertext = req.body.SpeechResult;
   let confidence = req.body.Confidence
@@ -343,9 +339,7 @@ router.post('/nextblock_old/:callSid/', async(req, res) => {
 
 router.post('/nextblock/: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);
-  console.log("(voice) called POST /nextblock at" + new Date() + "with text: " + req.body.SpeechResult)
+  winston.verbose("(voice) called POST /nextblock at " + new Date() + "with text: "+ req.body.SpeechResult);
   
   let usertext = req.body.SpeechResult;
   let confidence = req.body.Confidence
@@ -389,13 +383,13 @@ router.post('/nextblock/:callSid/', async(req, res) => {
   
   let start_promise_message= new Date();
   let message = await new Promise(async (resolve, reject) => {
-    winston.debug('******* user text -->'+ usertext)
+    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]')
+      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 
@@ -409,13 +403,12 @@ router.post('/nextblock/:callSid/', async(req, res) => {
       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 /nextblock/${callSid} : ` + end_time_send_message-start_time_send_message + '[ms] with text ' + tdMessage.text + ' --- at time:' + 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())
+      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
@@ -427,14 +420,14 @@ router.post('/nextblock/:callSid/', async(req, res) => {
     }
   })
   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())  
+  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()
-  console.log(`Time to responde to /nextblock/${callSid} : `, end_call-start_call, '[ms]')
+  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');
@@ -467,7 +460,7 @@ async function getMessage(callSid, ani, project_id, conversation_id){
 
       // 1. First attempt: read from queue
       queue = await tdChannel.getMessagesFromQueue(conversation_id)
-      console.log('[getMessage] /NEXT check queue length--> '+ queue.length)
+      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
@@ -528,11 +521,8 @@ async function getMessage(callSid, ani, project_id, conversation_id){
 }
 
 router.post('/speechresult/:callSid', async (req, res) => {
-  
   let start_call = new Date();
-  winston.verbose("(voice) called POST /speechresult ", req.body);
-  winston.verbose("(voice) called POST /speechresult query ", req.query);
-  console.log('/speechresult at: ', new Date(), 'with text:', req.body.SpeechResult)
+  winston.verbose("(voice) called POST /speechresult at" + new Date() + "with text: "+ req.body.SpeechResult);
   
   let usertext = req.body.SpeechResult;
   let confidence = req.body.Confidence
@@ -572,54 +562,200 @@ router.post('/speechresult/:callSid', async (req, res) => {
     uploadService: uploadService
   });
   
-  winston.verbose("(voice) usertext "+usertext);
-  let message = {};
-  if(usertext){
-    let tiledeskMessage= {
-      text:usertext,
-      senderFullname: from,
-      type: 'text',
-      channel: { name: CHANNEL_NAME }
-    };
-    let startSend= new Date().getTime()
-    let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
-    winston.debug("message sent : ", tdMessage);
-    let endSend = new Date().getTime();
-    console.log('Time to send messagge ( ', usertext, '): ', endSend - startSend, '[ms] at time', new Date())
-    //generate Tiledesk wait message
-    let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
-    message = await tdChannel.generateWaitTdMessage(from, delayTime)
-    //update delayIndex for wait command message time
-    await voiceChannel.saveDelayIndexForCallId(callSid)
-    
-  }else {
-    
-    let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
-    message = await tdChannel.generateWaitTdMessage(from, delayTime)
-    //update delayIndex for wait command message time
-    await voiceChannel.saveDelayIndexForCallId(from)
-  }
   
+  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 sessionInfo;
+  let project_id, conversation_id, user;
+  let from, to;
+
+  let redis_data = await redis_client.get('tiledesk:voice:'+callSid+':session');
+  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 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 end_call = new Date()
-  console.log('Time to responde to /speechresult/:callSid : ', end_call-start_call, '[ms]')
+  let sessionInfo;
+  let project_id, conversation_id, user;
+  let from, to;
+  
+  let redis_data = await redis_client.get('tiledesk:voice:'+callSid+':session');
+  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;
+  
+  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) => {
-  winston.verbose("(voice) called POST /menu", req.body);
-  winston.verbose("(voice) called POST /menu query" , req.query);
   let start_call = new Date().getTime();
-  console.log('/menublock at: ', new Date(), 'with text:', req.body.Digits)
+  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 = {};
@@ -697,7 +833,6 @@ router.post('/menublock/:callSid', async (req, res) => {
     uploadService: uploadService
   });
   
-  let startSend = new Date().getTime();
   //send message to tiledesk 
   let tiledeskMessage= {
     text:message_text,
@@ -706,30 +841,35 @@ router.post('/menublock/:callSid', async (req, res) => {
     channel: { name: CHANNEL_NAME },
     attributes: attributes
   };
-  let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
-  let endSend = new Date().getTime();
-  console.log('(menu) Time to send messagge ( ', message_text, '): ', endSend - startSend, '[ms] at time', new Date())
+  let response = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
+  if(!response){
+    return res.status(503).send({ message: "Bad response: Quota exceeded" })
+  }
 
-  //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)
+  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);
   
-  res.set('Content-Type', 'application/xml');
-  res.status(200).send(messageToVXML);
-
   let end_call = new Date().getTime();
-  console.log('Time to responde to /menublock/<call_id>/ : ', end_call-start_call, '[ms]')
+  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.verbose("(voice) called POST /handle", req.body);
+  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);
   
@@ -808,7 +948,7 @@ router.post('/handle/:callSid/:event', async (req, res) => {
 
 /* ----> catch Event block <----- */
 router.post('/event/:callSid/:event', async(req, res)=> {
-  winston.verbose("(voice) called POST /event" , req.params);
+  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);
   
@@ -912,7 +1052,7 @@ router.post('/event/:callSid/:event', async(req, res)=> {
 
 /* ----> catch Twilio Events <----- */
 router.post('/twilio/status',async (req, res) => {
-  winston.verbose('+++++++++++(voice) called POST twilio/status ', req.body);
+  winston.debug('+++++++++++(voice) called POST twilio/status ', req.body);
   
   let event = req.body.CallStatus;
   let callSid = req.body.CallSid;
@@ -978,8 +1118,7 @@ router.post('/twilio/status',async (req, res) => {
       let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
 
       //remove session data for current callId and relative queue data
-      await redis_client.del('tiledesk:voice:'+callSid+':session');
-      await redis_client.del('tiledesk:voice:'+callSid+':delayIndex');
+      await voiceChannel.deleteCallKeys(callSid);
       await tdChannel.clearQueue(conversation_id);
       break;
     }
@@ -992,7 +1131,7 @@ router.post('/twilio/status',async (req, res) => {
 
 
 router.post('/twilio/fail',async (req, res) => {
-  winston.verbose('+++++++++++(voice) called POST twilio/fail ', req.params)
+  winston.debug('+++++++++++(voice) called POST twilio/fail ', req.params)
   winston.debug('+++++++++++(voice) called POST twilio/fail ', req.body)
 
   res.set('Content-Type', 'application/xml');
@@ -1000,175 +1139,100 @@ router.post('/twilio/fail',async (req, res) => {
 })
 
 
-/* ----> catch Twilio Events <----- */
-router.post('/record/:callSid/',async (req, res) => {
-  winston.verbose('+++++++++++(voice) called POST record/:callSid ', req.body);
-  
-  let callSid = req.body.CallSid;
-  let audioFileUrl = req.body.RecordingUrl;
-  
-  let sessionInfo;
-  let project_id, conversation_id, user;
-  let from, to;
-  
-  let redis_data = await redis_client.get('tiledesk:voice:'+callSid+':session');
-  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
-  });
-  
-  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 attributes = await voiceChannel.getSettingsForCallId(callSid);
-  console.log('attributessss', attributes)
-  
-  //SPEECH TO TEXT
-  console.log('getting text message  . . . ', audioFileUrl, attributes.STT_MODEL)
-  let tiledeskMessage = await generateSTT(audioFileUrl, attributes, sessionInfo, settings)
-  console.log('(voice) Message captured after STT -->', tiledeskMessage)
-  
-  if(!tiledeskMessage){
-    //case NO_INPUT
-    const queryString = utils.buildQueryString(req.query);
-    winston.debug('case no input.. redirect '+ queryString)
-    
-    return await axios({
-      url: "http://localhost:3000/handle/" + callSid + '/no_input'+ queryString,
-      headers: req.headers,
-      data: req.body,
-      method: 'POST'
-    }).then((response) => {
-      winston.debug("[TiledeskChannel] speechToText response : ", response.data);
-      return res.status(response.status).send(response.data);
-    }).catch((err) => {
-      winston.error("[TiledeskChannel] speechToText error: ", err);
-      return res.status(500).send({ success: false, message: "Errore while redirect to /handle for callSid " + callSid});;
-    })
-  }
-  
-
-  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)
-
-  // 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);
-
-})
 
 async function generateSTT(audioFileUrl, attributes, sessionInfo, settings){
     
   winston.debug("(voice) generateSTT: "+ attributes.VOICE_PROVIDER);
     
-  let tiledeskMessage = {}, text = null;
-  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).catch((err)=>{
-            winston.error('errr while checkQuoteAvailability for project:', sessionInfo.project_id, err.response?.data)
-        })
-        winston.verbose('(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'
-            }
-          };
+  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;
       }
-      
-      text = await aiService.speechToText(audioFileUrl, attributes.STT_MODEL, GPT_KEY).catch((err)=>{
-          winston.error('errr while transcript', err.response?.data)
-      })
-      tiledeskMessage= {
-        text: text,
-        senderFullname: sessionInfo.from,
-        type: 'text',
-        channel: { name: CHANNEL_NAME }
-      };
-      break;
-    case VOICE_PROVIDER.ELEVENLABS:
-      let ELEVENLABS_APIKEY = sessionInfo.integrations.find((el => el.type === VOICE_PROVIDER.ELEVENLABS))?.key
-      // La condizione negli input del metodo è corretta, ma può essere scritta in modo più leggibile:
-      const ttsLanguage = attributes.TTS_LANGUAGE || 'en';
-      text = await this.aiService.speechToTextElevenLabs(
-        audioFileUrl,
-        attributes.STT_MODEL,
-        ttsLanguage,
-        ELEVENLABS_APIKEY
-      ).catch((err) => {
-        winston.error('errr while creating elevenlabs audio message', err?.response?.data);
-      });
-      tiledeskMessage= {
+      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 }
       };
-      break;
+    }
+  } 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.verbose("(voice) called GET /transcript query-->" , req.query);
+  winston.debug("(voice) called GET /transcript query-->" , req.query);
   winston.debug("(voice) called GET /transcript body -->" , req.body);
   
   res.status(200).send('ok');
@@ -1177,7 +1241,7 @@ router.get('/addon/transcript', async (req, res) => {
 
 /**   --> only for test purpose <--   **/
 router.get('/test', async (req, res) => {
-  winston.verbose("(voice) called GET /test" , req.query);
+  winston.debug("(voice) called GET /test" , req.query);
   
   let project_id = req.query.id_project;
   let callSid = req.body.CallSid;
@@ -1354,7 +1418,7 @@ async function connectRedis() {
   
   
   redis_client.on('error', err => {
-    winston.debug('(voice) Connect Redis Error ' + err);
+    winston.error('(voice) Connect Redis Error ' + err);
   })
   /*
   redis_client.on('connect', () => {