@tiledesk/tiledesk-voice-twilio-connector 0.1.26-rc12 → 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");
@@ -156,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
@@ -240,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');
@@ -252,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
@@ -326,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]')
@@ -339,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;
@@ -405,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()
@@ -423,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)
@@ -525,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;
@@ -612,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]`)
@@ -622,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 = {};
@@ -731,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]`)
@@ -810,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);
@@ -915,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);
@@ -990,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;
     }
@@ -1012,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiledesk/tiledesk-voice-twilio-connector",
-  "version": "0.1.26-rc12",
+  "version": "0.1.26-rc13",
   "description": "Tiledesk VOICE Twilio connector",
   "license": "MIT",
   "author": "Gabriele Panico",

package/tiledesk/TiledeskChannel.js

@@ -266,7 +266,7 @@ class TiledeskChannel {
   /** SUBSCRIBE TO REDIS TOPIC */
   async subscribeToTopic(conversation_id){
     const topic = `tiledesk:conversation:${conversation_id}`;
-    console.log("subscribeToTopic: " + topic);
+    // console.log("subscribeToTopic: " + topic);
 
     // duplichi il client principale
     const subscriber = this.redis_client.duplicate();

package/tiledesk/TiledeskTwilioTranslator.js

@@ -11,11 +11,16 @@ const SETTING_MESSAGE = require('./constants').SETTING_MESSAGE
 const CHANNEL_NAME = require('./constants').CHANNEL_NAME
 const VOICE_PROVIDER = require('./constants').VOICE_PROVIDER;
 const OPENAI_SETTINGS = require('./constants').OPENAI_SETTINGS;
+const ELEVENLABS_SETTINGS = require('./constants').ELEVENLABS_SETTINGS;
 
 const TYPE_ACTION_VXML = require('./constants').TYPE_ACTION_VXML
 const TYPE_MESSAGE = require('./constants').TYPE_MESSAGE
 const INFO_MESSAGE_TYPE = require('./constants').INFO_MESSAGE_TYPE
 
+const voiceEventEmitter = require('./services/voiceEventEmitter');
+
+const { SttError } = require('./errors');
+
 class TiledeskTwilioTranslator {
   /**
    * Constructor for TiledeskVXMLTranslator
@@ -67,8 +72,8 @@ class TiledeskTwilioTranslator {
       this.voiceProvider = VOICE_PROVIDER.TWILIO
       if(flowAttributes.VOICE_PROVIDER){
         this.voiceProvider = flowAttributes.VOICE_PROVIDER
-        
       }
+      vxmlAttributes.VOICE_PROVIDER = this.voiceProvider;
       
       // IF VOICE_PROVIDER is TWILIO --> default values is on user account twilio settings
       // IF VOICE_PROVIDER is OPENAI --> set default values from constants
@@ -84,13 +89,14 @@ class TiledeskTwilioTranslator {
         vxmlAttributes.TTS_VOICE_NAME = flowAttributes.TTS_VOICE_NAME? flowAttributes.TTS_VOICE_NAME : ELEVENLABS_SETTINGS.TTS_VOICE_NAME;
         vxmlAttributes.TTS_MODEL = flowAttributes.TTS_MODEL? flowAttributes.TTS_MODEL : ELEVENLABS_SETTINGS.TTS_MODEL;
         vxmlAttributes.TTS_VOICE_LANGUAGE = flowAttributes.TTS_VOICE_LANGUAGE? flowAttributes.TTS_VOICE_LANGUAGE : ELEVENLABS_SETTINGS.TTS_VOICE_LANGUAGE;
+        vxmlAttributes.STT_MODEL = flowAttributes.STT_MODEL? flowAttributes.STT_MODEL : ELEVENLABS_SETTINGS.STT_MODEL;
       }
       
     }
     
-    
-    
     winston.debug("[TiledeskVXMLTranslator] manageVoiceAttributes: vxmlAttributes returned:", vxmlAttributes);
+    voiceEventEmitter.emit('saveSettings', vxmlAttributes);
+
     return vxmlAttributes
   }
   
@@ -288,6 +294,9 @@ class TiledeskTwilioTranslator {
 
   async delayVXMLConverter(rootEle, message, xmlAttributes){
     const command = message.attributes.commands[0]
+
+    const prompt = this.promptVXML(rootEle, message, xmlAttributes);
+
     rootEle.ele("Redirect", {method: "POST"}, this.BASE_URL + '/nextblock/' + xmlAttributes.callSid).up()
     
     return rootEle.end({ pretty: true });                                        
@@ -296,7 +305,7 @@ class TiledeskTwilioTranslator {
 
   async playPromptVXMLConverter(rootEle, message, xmlAttributes){
     
-    const prompt = this.promptVXML(rootEle, message, xmlAttributes);
+    const prompt = await this.promptVXML(rootEle, message, xmlAttributes);
     
     const queryUrl = '?intentName='+ querystring.encode(xmlAttributes.intentName) + '&previousIntentTimestamp='+Date.now();
     rootEle.ele("Redirect", {method: "POST"}, this.BASE_URL + '/nextblock/' + xmlAttributes.callSid + queryUrl).up()
@@ -314,7 +323,8 @@ class TiledeskTwilioTranslator {
       const gather = rootEle.ele("Gather", { input: "speech"})
 
       const queryUrl = '?intentName='+ querystring.encode(xmlAttributes.intentName) + "&previousIntentTimestamp="+Date.now();
-      gather.att("action", this.BASE_URL + '/speechresult/' + xmlAttributes.callSid + queryUrl)
+      gather.att("action", this.BASE_URL + '/nextBlock/' + xmlAttributes.callSid + queryUrl)
+      // gather.att("action", this.BASE_URL + '/speechresult/' + xmlAttributes.callSid + queryUrl)
             .att("method", "POST")
             .att("language", xmlAttributes.TTS_VOICE_LANGUAGE)
             .att('speechTimeout', "auto")
@@ -346,15 +356,16 @@ class TiledeskTwilioTranslator {
       }
       
       record
-          //.att("action", this.BASE_URL + '/record/' + xmlAttributes.callSid + queryUrl)
+          .att("action", this.BASE_URL + '/record/action/' + xmlAttributes.callSid + queryUrl)
           .att("method", "POST")
           .att("trim", "trim-silence")
-          .att("recordingStatusCallback", this.BASE_URL + '/record/' + xmlAttributes.callSid + queryUrl)
+          .att("timeout", "2")
+          .att("recordingStatusCallback", this.BASE_URL + '/record/callback/' + xmlAttributes.callSid + queryUrl)
           .att("recordingStatusCallbackMethod", "POST")
       
-      if(xmlAttributes && xmlAttributes.noInputTimeout){
-        record.att("timeout",  xmlAttributes.noInputTimeout/1000 ).up();
-      }
+      // if(xmlAttributes && xmlAttributes.noInputTimeout){
+      //   record.att("timeout",  xmlAttributes.noInputTimeout/1000 ).up();
+      // }
       
     }
     
@@ -373,7 +384,7 @@ class TiledeskTwilioTranslator {
     let queryUrl = '?intentName='+ querystring.encode(xmlAttributes.intentName) + '&previousIntentTimestamp='+Date.now() + '&menu_options=' + menu_options;
     const handleNoInputNoMatchQuery = await this.handleNoInputNoMatch(rootEle, message, xmlAttributes);
     if(handleNoInputNoMatchQuery && handleNoInputNoMatchQuery.queryNoMatch){
-      queryUrl += '&button_action='+ handleNoInputNoMatchQuery.queryNoMatch.split('button_action=')[1]
+      queryUrl += '&'+ handleNoInputNoMatchQuery.queryNoMatch
     }
       
     const gather = rootEle.ele("Gather", { input: "dtmf"})
@@ -477,7 +488,7 @@ class TiledeskTwilioTranslator {
       }
       
       
-      queryNoInput = 'intentName='+ querystring.encode(attributes.intentName) + '&previousIntentTimestamp='+Date.now() + '&button_action='+button_noIput.action.substring(1);
+      queryNoInput = 'button_action='+button_noIput.action.substring(1);
       //rootEle.ele("Redirect", {}, this.BASE_URL + '/handle/' + attributes.callSid + '/no_input'+ queryNoInput)
       
 
@@ -504,7 +515,7 @@ class TiledeskTwilioTranslator {
         value: 'no_match'
       }
       
-      queryNoMatch = 'intentName='+ querystring.encode(attributes.intentName) + '&previousIntentTimestamp='+Date.now() + '&button_action='+button_noMatch.action.substring(1); //remove '#' from intentId because is not a valid char for XML lang
+      queryNoMatch = 'button_action='+button_noMatch.action.substring(1); //remove '#' from intentId because is not a valid char for XML lang
       //rootEle.ele("Redirect", {}, this.BASE_URL + '/handle/' + attributes.callSid + '/no_match'+ queryNoMatch)
       
       /*element.ele("nomatch")
@@ -629,29 +640,45 @@ class TiledeskTwilioTranslator {
   }
   
   async generateTTS(text, attributes){
-    
     let audioData = null;
-    switch(this.voiceProvider){
-      case VOICE_PROVIDER.OPENAI:
-        let GPT_KEY = this.integrations.find((el => el.type === VOICE_PROVIDER.OPENAI))?.key
-        audioData = await this.aiService.textToSpeech(text, attributes.TTS_VOICE_NAME, attributes.TTS_MODEL, GPT_KEY).catch((err)=>{
-          console.log('errr while creating audio message', err.response?.data)
-        })
-        break;
-      case VOICE_PROVIDER.ELEVENLABS:
-        let ELEVENLABS_APIKEY = this.integrations.find((el => el.type === VOICE_PROVIDER.ELEVENLABS))?.key
-        audioData = await this.aiService.textToSpeechElevenLabs(text, attributes.TTS_VOICE_NAME, attributes.TTS_MODEL, attributes.TTS_VOICE_LANGUAGE, ELEVENLABS_APIKEY).catch((err)=>{
-          console.log('errr while creating elevenlabs audio message', err.response?.data)
-        })
-        break;
+    try {
+      switch(this.voiceProvider){
+        case VOICE_PROVIDER.OPENAI:
+          let GPT_KEY = this.integrations.find((el => el.type === VOICE_PROVIDER.OPENAI))?.key
+          audioData = await this.aiService.textToSpeech(text, attributes.TTS_VOICE_NAME, attributes.TTS_MODEL, GPT_KEY)
+          break;
+        case VOICE_PROVIDER.ELEVENLABS:
+          let ELEVENLABS_APIKEY = this.integrations.find((el => el.type === VOICE_PROVIDER.ELEVENLABS))?.key
+          audioData = await this.aiService.textToSpeechElevenLabs(text, attributes.TTS_VOICE_NAME, attributes.TTS_MODEL, attributes.TTS_VOICE_LANGUAGE, ELEVENLABS_APIKEY)
+          break;
+        default:
+          throw new SttError('TTS_FAILED', 'Unsupported voice provider: ' + this.voiceProvider);
+      }
+      
+      if (!audioData) {
+        throw new SttError('TTS_FAILED', 'TTS returned no audio data');
+      }
 
+      let fileUrl = await this.uploadService.upload(attributes.callSid, audioData, this.user)
+      winston.debug('(voice) Audio Message url captured after TTS -->', fileUrl)
+      return fileUrl
+    } catch (error) {
+      winston.error('(voice) TTS generation error:', error);
+      switch (error.code) {
+        case 'TTS_FAILED':
+          winston.error('(voice) TTS_FAILED:', error.message);
+          break;
+        case 'AI_SERVICE_ERROR':
+          winston.error('(voice) AI_SERVICE_ERROR:', error.message);
+          break;
+        case 'UPLOAD_SERVICE_ERROR':
+          winston.error('(voice) UPLOAD_SERVICE_ERROR:', error.message);
+          break;
+        default:
+          throw new SttError('TTS_FAILED', 'TTS generation failed: ' + error.message);
+      }
     }
     
-    let fileUrl = await this.uploadService.upload(attributes.callSid, audioData, this.user).catch((err)=>{
-      console.log('errr while uploading audioData', err.response)
-    })
-    console.log('(voice) Audio Message url captured after TTS -->', fileUrl)
-    return fileUrl
   }
   
   

package/tiledesk/VoiceChannel.js

@@ -4,17 +4,10 @@ const jwt = require("jsonwebtoken");
 const { v4: uuidv4 } = require("uuid");
 const { promisify } = require('util');
 
-/*UTILS*/
-const utils = require('./utils-message.js')
-const TYPE_MESSAGE = require('./constants').TYPE_MESSAGE
-const MESSAGE_TYPE_MINE = require('./constants').MESSAGE_TYPE_MINE
-const MESSAGE_TYPE_OTHERS = require('./constants').MESSAGE_TYPE_OTHERS
-const CHANNEL_NAME = require('./constants').CHANNEL_NAME
-const VOICE_PROVIDER = require('./constants').VOICE_PROVIDER;
-const OPENAI_SETTINGS = require('./constants').OPENAI_SETTINGS;
-
 const winston = require("../winston");
 
+const voiceEventEmitter = require('./services/voiceEventEmitter');
+
 class VoiceChannel {
 
 
@@ -48,8 +41,21 @@ class VoiceChannel {
     }
     
     this.redis_client = config.redis_client
+
+    this.listenToVoiceEvents();
     
   }
+
+
+  listenToVoiceEvents(){
+
+    voiceEventEmitter.on('saveSettings', async (data) => {
+      winston.debug('[VoiceChannel] listenToVoiceEvents: saveSettings event received -->', data)
+      if(data){
+        await this.saveSettingsForCallId(data, data.callSid);
+      }
+    });
+  }
   
   
   async getNextDelayTimeForCallId(callId){
@@ -69,11 +75,11 @@ class VoiceChannel {
       //increment 
       const delayIndex = (+index) +1
       //save new index to redis
-      await this.redis_client.set('tiledesk:voice:'+callId + ':delayIndex', delayIndex, {'EX': 86400});
+      await this.redis_client.set('tiledesk:voice:'+callId + ':delayIndex', delayIndex, 'EX', 86400);
       return;
     }
     //if index is not present: set to default (0)
-    await this.redis_client.set('tiledesk:voice:'+callId + ':delayIndex', 0, {'EX': 86400});
+    await this.redis_client.set('tiledesk:voice:'+callId + ':delayIndex', 0, 'EX', 86400);
   }
   
   /** RESET INDEX INTO REDIS DATA FOR CURRENT CALLID **/
@@ -94,50 +100,49 @@ class VoiceChannel {
   
   async saveSettingsForCallId(attributes, callId){
     
-    winston.debug('saveSettingsForCallId: attributes -->', attributes)
-    let flowAttributes = {}
-    if(attributes && attributes.flowAttributes){
-      
-      flowAttributes = attributes.flowAttributes;
-      
-      //MANAGE VOICE SETTINGS from globals attributes
-      let voiceProvider = VOICE_PROVIDER.TWILIO
-      if(flowAttributes.VOICE_PROVIDER){
-        voiceProvider = flowAttributes.VOICE_PROVIDER
-        
-      }
-      
-      // IF VOICE_PROVIDER is TWILIO --> default values is on user account twilio settings
-      // IF VOICE_PROVIDER is OPENAI --> set default values from constants
-      if(voiceProvider === VOICE_PROVIDER.OPENAI){
-        flowAttributes.TTS_VOICE_NAME = flowAttributes.TTS_VOICE_NAME? flowAttributes.TTS_VOICE_NAME : OPENAI_SETTINGS.TTS_VOICE_NAME;
-        flowAttributes.TTS_MODEL = flowAttributes.TTS_MODEL? flowAttributes.TTS_MODEL : OPENAI_SETTINGS.TTS_MODEL;
-        flowAttributes.STT_MODEL = flowAttributes.STT_MODEL? flowAttributes.STT_MODEL : OPENAI_SETTINGS.STT_MODEL;
-      }
-            
-      
-    }
+    winston.debug('[VoiceChannel] saveSettingsForCallId: attributes -->', attributes)
     
     const index = await this.redis_client.get('tiledesk:voice:'+callId + ':attributes');
-    winston.debug('saveSettingsForCallId: attributes found -->'+index)
+    winston.debug('[VoiceChannel] saveSettingsForCallId: attributes found -->'+index)
     if(index){
       //set index to default (0)
-      await this.redis_client.set('tiledesk:voice:'+callId + ':attributes', JSON.stringify(flowAttributes), {'EX': 86400});
+      await this.redis_client.set('tiledesk:voice:'+callId + ':attributes', JSON.stringify(attributes), 'EX', 86400);
       return;
     }
     //if index is not present: set to default (0)
-    await this.redis_client.set('tiledesk:voice:'+callId + ':attributes', JSON.stringify(flowAttributes), {'EX': 86400});
+    await this.redis_client.set('tiledesk:voice:'+callId + ':attributes', JSON.stringify(attributes), 'EX', 86400);
   
   }
   
   
   async getSettingsForCallId(callId){
     const attributes = await this.redis_client.get('tiledesk:voice:'+callId + ':attributes');
+    winston.debug('[VoiceChannel] getSettingsForCallId: attributes found -->', attributes, callId)
     if(attributes){
       return JSON.parse(attributes)
     }
     return {};
   }
+
+
+  async deleteCallKeys(callSid) {
+    const pattern = `tiledesk:voice:${callSid}:*`;
+    let cursor = 0;
+
+    do {
+      const reply = await this.redis_client.scan(cursor, {
+        MATCH: pattern,
+        COUNT: 100
+      });
+
+      cursor = reply.cursor;
+      const keys = reply.keys;
+
+      if (keys.length > 0) {
+        await this.redis_client.del(keys);
+      }
+    } while (cursor !== 0);
+  }
   
   
 

package/tiledesk/constants.js

@@ -62,6 +62,17 @@ module.exports = {
   ELEVENLABS_SETTINGS:{
     TTS_VOICE_NAME: '21m00Tcm4TlvDq8ikWAM',
     TTS_MODEL: 'eleven_multilingual_v2',
-    TTS_VOICE_LANGUAGE: 'en'
-  }
+    TTS_VOICE_LANGUAGE: 'en',
+    STT_MODEL: 'scribe_v1'
+  },
+  NON_SPEECH_TOKENS: [
+    '(music)',
+    '(noise)',
+    '(silence)',
+    '(background noise)',
+    '(applause)',
+    '(breathing)',
+    '(laughs)',
+    '(laughter)'
+  ]
 }

package/tiledesk/errors.js

@@ -0,0 +1,28 @@
+class SttError extends Error {
+  constructor(code, message, extra = {}) {
+    super(message);
+    this.code = code;       // es. 'AUDIO_DOWNLOAD_FAILED'
+    this.extra = extra;     // opzionale, eventuali dati aggiuntivi
+  }
+}
+
+class RedisError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+
+class ServiceError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+
+// esporta tutte insieme
+module.exports = {
+  SttError,
+  RedisError,
+  ServiceError
+};

package/tiledesk/services/AiService.js

@@ -2,6 +2,9 @@ var winston = require('../../winston');
 const axios = require("axios").default;
 const FormData = require('form-data');
 
+/*ERROR HANDLER*/
+const { ServiceError } = require('../errors');
+
 /*UTILS*/
 const fileUtils = require('../fileUtils.js')
 
@@ -30,44 +33,52 @@ class AiService {
   }
   
   async speechToText(fileUrl, model, GPT_KEY) {
-
+    let start_time = new Date(); 
     winston.debug("[AiService] speechToText url: "+ fileUrl);   
-    let file = await fileUtils.downloadFromUrl(fileUrl).catch((err) => {
-        winston.error("[AiService] err while downloadFromUrl: ", err)
-        return null; // fallback per evitare undefined
-    })
-    
-    if (!file) {
-      winston.error('file non esisteeeeeeee')
-      return;
-    }
     
-    return new Promise((resolve, reject) => {
-      
+    return new Promise(async (resolve, reject) => {
       
-      const formData = new FormData();
-      formData.append('file', file, { filename: 'audiofile.wav', contentType: 'audio/wav' });
-      formData.append('model', model);
+      try {
+        let file = await fileUtils.downloadFromUrl(fileUrl).catch((err) => {
+            winston.error("[AiService] err while downloadFromUrl: ", err)
+            return reject(new ServiceError('AISERVICE_FAILED', 'Cannot download audio file:', fileUrl));
+        })
+        
+        if (!file) {
+          winston.debug('[AiService] OPENAI speechToText file NOT EXIST: . . . return')
+          return reject(new ServiceError('AISERVICE_FAILED', 'Cannot download audio file: file is null'));
+        }
 
-      axios({
-        url: `${this.OPENAI_ENDPOINT}/audio/transcriptions`,
-        headers: {
-          ...formData.getHeaders(),
-          "Authorization": "Bearer " + GPT_KEY
-        },
-        data: formData,
-        method: 'POST'
-      }).then((resbody) => {
-        resolve(resbody.data.text);
-      }).catch((err) => {
-        reject(err);
-      })
+        const formData = new FormData();
+        formData.append('file', file, { filename: 'audiofile.wav', contentType: 'audio/wav' });
+        formData.append('model', model);
+
+        axios({
+          url: `${this.OPENAI_ENDPOINT}/audio/transcriptions`,
+          headers: {
+            ...formData.getHeaders(),
+            "Authorization": "Bearer " + GPT_KEY
+          },
+          data: formData,
+          method: 'POST'
+        }).then((resbody) => {
+          resolve(resbody.data.text);
+          let end_time = new Date();
+          winston.verbose(`-----> [AiService] OpenAI speechToText time elapsed: ${end_time - start_time} ms`);
+        }).catch((err) => {
+          reject(new ServiceError('AISERVICE_FAILED', 'OpenAI /audio/transcriptions API failed with err:', err));
+        })
+      } catch (error) {
+        winston.error("[AiService] OpenAI STT error", err.message);
+        reject(new ServiceError('AISERVICE_FAILED', 'OpenAI STT service failed with err:', err));
+      }
+      
 
     })
   }
   
   async textToSpeech(text, name, model, GPT_KEY){
-    
+    let start_time = new Date();
     winston.debug('[AiService] textToSpeech text:'+ text)
     
     const data = {
@@ -76,7 +87,6 @@ class AiService {
       voice: name,
     };
     
-    
     winston.debug('[AiService] textToSpeech config:', data)
     
     return new Promise((resolve, reject) => {
@@ -91,11 +101,13 @@ class AiService {
         method: "POST",
       }).then( async (response) => {
         //console.log('[AiService] textToSpeech result', response?.data)
-        resolve(response?.data)            
+        resolve(response?.data)  
+        let end_time = new Date();
+        winston.verbose(`-----> [AiService] textToSpeech time elapsed: ${end_time - start_time} ms`);          
       })
       .catch((err) => {
         winston.error("[AiService] textToSpeech error: ", err.response?.data);
-        reject(err)
+        reject(new ServiceError('AISERVICE_FAILED', 'OpenAI textToSpeech API failed with err:', err));
       });
     });
     
@@ -104,45 +116,53 @@ class AiService {
   
   
   async speechToTextElevenLabs(fileUrl, model, language, API_KEY) {
-
+    let start_time = new Date();
     winston.debug("[AiService] ELEVEN Labs speechToText url: "+ fileUrl);   
-    let file = await fileUtils.downloadFromUrl(fileUrl).catch((err) => {
-        winston.error("[AiService] err: ", err)
-        return null; // fallback per evitare undefined
-    })
     
-    if (!file) {
-      winston.debug('[AiService] ELEVEN Labs speechToText file NOT EXIST: . . . return')
-      return;
-    }
-    
-    return new Promise((resolve, reject) => {
+    return new Promise(async (resolve, reject) => {
+
+      try {
+        let file = await fileUtils.downloadFromUrl(fileUrl).catch((err) => {
+          winston.error("[AiService] err: ", err)
+          return reject(new ServiceError('AISERVICE_FAILED', 'Cannot download audio file:', fileUrl));
+        })
+        
+        if (!file) {
+          winston.debug('[AiService] ELEVEN Labs speechToText file NOT EXIST: . . . return')
+          return reject(new ServiceError('AISERVICE_FAILED', 'Cannot download audio file: file is null'));
+        }
       
       
-      const formData = new FormData();
-      formData.append('file', file, { filename: 'audiofile.wav', contentType: 'audio/wav' });
-      formData.append('model_id', "scribe_v1");
-      formData.append('language_code', language)
+        const formData = new FormData();
+        formData.append('file', file, { filename: 'audiofile.wav', contentType: 'audio/wav' });
+        formData.append('model_id', "scribe_v1");
+        formData.append('language_code', language)
 
-      axios({
-        url: `${this.ELEVENLABS_ENDPOINT}/v1/speech-to-text`,
-        headers: {
-          ...formData.getHeaders(),
-          "xi-api-key": API_KEY
-        },
-        data: formData,
-        method: 'POST'
-      }).then((resbody) => {
-        resolve(resbody.data.text);
-      }).catch((err) => {
-        reject(err);
-      })
+        axios({
+          url: `${this.ELEVENLABS_ENDPOINT}/v1/speech-to-text`,
+          headers: {
+            ...formData.getHeaders(),
+            "xi-api-key": API_KEY
+          },
+          data: formData,
+          method: 'POST'
+        }).then((resbody) => {
+          resolve(resbody.data.text);
+          let end_time = new Date();
+          winston.verbose(`-----> [AiService] ELEVEN Labs speechToText time elapsed: ${end_time - start_time} ms`);
+        }).catch((err) => {
+          reject(new ServiceError('AISERVICE_FAILED', 'ElevenLabs /speech-to-text API failed with err:', err));
+        })
+      } catch (error) {
+        winston.error("[AiService] ElevenLabs STT error", err.message);
+        reject(new ServiceError('AISERVICE_FAILED', 'ElevenLabs STT service failed with err:', err));
+      }
 
     })
   }
   
   async textToSpeechElevenLabs(text, voice_id, model, language_code, API_KEY){
-    
+    let start_time = new Date();
     const data = {
       model_id: model,
       text: text,
@@ -161,11 +181,13 @@ class AiService {
         data: data,
         method: "POST",
       }).then( async (response) => {
-        resolve(response?.data)            
+        resolve(response?.data)
+        let end_time = new Date();
+        winston.verbose(`-----> [AiService] ELEVEN Labs textToSpeech time elapsed: ${end_time - start_time} ms`);            
       })
       .catch((err) => {
         winston.error("[AiService] ELEVEN Labs textToSpeech error: ", err);
-        reject(err)
+        reject(new ServiceError('AISERVICE_FAILED', 'ElevenLabs textToSpeech API failed with err:', err));
       });
     });
     
@@ -194,7 +216,7 @@ class AiService {
         }
       }).catch((err) => {
         winston.error("[AiService] checkQuoteAvailability error: ", err.response?.data);
-        reject(err);
+        reject(new ServiceError('AISERVICE_FAILED', 'checkQuoteAvailability API failed with err:', err));
       })
 
     })

package/tiledesk/services/UploadService.js

@@ -7,6 +7,9 @@ const path = require('path');
 /*UTILS*/
 const fileUtils = require('../fileUtils.js')
 
+/*ERROR HANDLER*/
+const { ServiceError } = require('../errors');
+
 class UploadService {
   
   constructor(config) {
@@ -69,7 +72,7 @@ class UploadService {
         
       }).catch((err) => {
         console.log('err', err)
-        reject(err);
+        reject(new ServiceError('UPLOADSERVICE_FAILED', 'UploadService /files/users API failed with err:', err) );
       }).finally(() => {
         // Sempre eseguito
         if (fs.existsSync(tempFilePath)) {

package/tiledesk/services/voiceEventEmitter.js

@@ -0,0 +1,6 @@
+const EventEmitter = require('events');
+class VoiceEventEmitter extends EventEmitter {}
+
+const voiceEventEmitter = new VoiceEventEmitter();
+
+module.exports = voiceEventEmitter;

package/tiledesk/utils.js

@@ -1,3 +1,4 @@
+const NON_SPEECH_TOKENS = require('./constants').NON_SPEECH_TOKENS
 
 function getNumber(phoneNumber){
   if(phoneNumber.startsWith('+')){
@@ -12,5 +13,23 @@ function buildQueryString(query) {
   return params.toString() ? `?${params.toString()}` : '';
 }
 
+function normalizeSTT(text) {
+  if (!text) return null;
 
-module.exports = {getNumber, buildQueryString}
+  const cleaned = text.trim().toLowerCase();
+
+  // solo token non verbali
+  if (NON_SPEECH_TOKENS.includes(cleaned)) {
+    return null;
+  }
+
+  // solo simboli o rumore
+  if (!/[a-zàèéìòù]/i.test(cleaned)) {
+    return null;
+  }
+
+  return cleaned;
+}
+
+
+module.exports = {getNumber, buildQueryString, normalizeSTT}