@tiledesk/tiledesk-voice-twilio-connector 0.1.26-rc11 → 0.1.26-rc13

package/index.js

@@ -98,12 +98,6 @@ router.post("/tiledesk", async (req, res) => {
   });
   tdChannel.setProjectId(project_id)
   
-  /*SKIP INFO MESSAGES*/
-  /*SKIP CURRENT USER MESSAGES*/
-  if(!utilsMess.messageType(TYPE_MESSAGE.INFO, tiledeskMessage) && !(tiledeskMessage.sender.indexOf("vxml") > -1) ){
-    winston.debug("> whook SAVE MESSAGE TO QUEUE " + JSON.stringify(tiledeskMessage) );
-  }
-  
   await tdChannel.addMessageToQueue(tiledeskMessage)
   
   res.send("(voice) Message received from Voice Twilio Proxy");
@@ -145,7 +139,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();
@@ -155,32 +150,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
@@ -226,7 +222,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 /webhook/:project_id : ' + (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)
@@ -239,7 +235,7 @@ router.post('/webhook/:id_project', async (req, res) => {
   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]`)
+  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');
@@ -251,7 +247,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
@@ -325,7 +320,7 @@ router.post('/nextblock_old/:callSid/', async(req, res) => {
   
   // convert response to vxml
   let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
-  winston.verbose("(voice) VXML to SEND: "+ messageToVXML);
+  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]')
@@ -338,8 +333,6 @@ 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);
   winston.verbose("(voice) called POST /nextblock at" + new Date() + "with text: "+ req.body.SpeechResult);
   
   let usertext = req.body.SpeechResult;
@@ -404,7 +397,6 @@ 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())
      
       let start_time_get_message = new Date()
@@ -422,7 +414,7 @@ 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)
@@ -524,8 +516,6 @@ async function getMessage(callSid, ani, project_id, conversation_id){
 
 router.post('/speechresult/:callSid', async (req, res) => {
   let start_call = new Date();
-  winston.debug("(voice) called POST /speechresult ", req.body);
-  winston.debug("(voice) called POST /speechresult query ", req.query);
   winston.verbose("(voice) called POST /speechresult at" + new Date() + "with text: "+ req.body.SpeechResult);
   
   let usertext = req.body.SpeechResult;
@@ -611,7 +601,7 @@ router.post('/speechresult/:callSid', async (req, res) => {
 
   // convert response to vxml
   let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
-  winston.verbose("(voice) VXML to SEND: "+ messageToVXML);
+  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]`)
@@ -621,12 +611,142 @@ router.post('/speechresult/:callSid', async (req, res) => {
   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());
+
+  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);
+  
+  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());
+  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 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]`)
+  
+  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)
+  winston.verbose('/menublock at: ' +  new Date() + 'with text:'+ req.body.Digits)
 
   let message_text = '';
   let attributes = {};
@@ -730,7 +850,7 @@ router.post('/menublock/:callSid', async (req, res) => {
 
   // convert response to vxml
   let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
-  winston.verbose("(voice) VXML to SEND: "+ messageToVXML);
+  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]`)
@@ -809,7 +929,7 @@ router.post('/handle/:callSid/:event', async (req, res) => {
 
   // convert response to vxml
   let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes,sessionInfo)
-  winston.verbose("(voice) VXML to SEND: "+ messageToVXML);
+  winston.debug("(voice) VXML to SEND: "+ messageToVXML);
   
   res.set('Content-Type', 'application/xml');
   res.status(200).send(messageToVXML);
@@ -914,7 +1034,7 @@ router.post('/event/:callSid/:event', async(req, res)=> {
 
   // convert response to vxml
   let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
-  winston.verbose("(voice) VXML to SEND: "+ messageToVXML);
+  winston.debug("(voice) VXML to SEND: "+ messageToVXML);
   
   res.set('Content-Type', 'application/xml');
   res.status(200).send(messageToVXML);
@@ -989,8 +1109,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;
     }
@@ -1011,172 +1130,97 @@ router.post('/twilio/fail',async (req, res) => {
 })
 
 
-/* ----> catch Twilio Events <----- */
-router.post('/record/:callSid/',async (req, res) => {
-  winston.debug('+++++++++++(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.verbose("(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.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'
-            }
-          };
+  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.debug("(voice) called GET /transcript query-->" , req.query);
@@ -1365,7 +1409,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', () => {