@tiledesk/tiledesk-voice-twilio-connector 0.1.22 → 0.1.24

package/index.js

@@ -58,6 +58,7 @@ let API_URL = null;
 let BASE_URL = null;
 let BASE_FILE_URL = null;
 let OPENAI_ENDPOINT = null;
+let ELEVENLABS_ENDPOINT = null;
 let REDIS_HOST = null;
 let REDIS_PORT = null;
 let REDIS_PASSWORD = null;
@@ -164,7 +165,7 @@ router.post('/webhook/:id_project', async (req, res) => {
   winston.debug("(voice) conversation returned:"+ conversation_id);
   
   
-   //GET AND SAVE GPT-KET IF 
+  //GET AND SAVE GPT-KET IF 
   let integrations = [], publicKey = false;
   let key = await integrationService.getKeyFromIntegrations(project_id, 'openai', settings.token)
   if (!key) {
@@ -179,6 +180,12 @@ router.post('/webhook/:id_project', async (req, res) => {
   }
   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})
+  }
+  
   //save data to redis
   let session_data = {
     from: from,
@@ -207,7 +214,7 @@ router.post('/webhook/:id_project', async (req, res) => {
     attributes: {
       subtype: 'info',
       payload: {
-        ... req.query //send all attributes back to chatbot
+        ... req.body //send all attributes back to chatbot
       }
     },
     channel: { name: CHANNEL_NAME },
@@ -321,12 +328,12 @@ router.post('/nextblock/:callSid/', async(req, res) => {
   // convert response to vxml
   let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
   winston.debug("(voice) VXML to SEND: "+ messageToVXML);
-  
+
   let end_call = new Date()
   console.log('Time to responde to /nextblock/:callSid : ', end_call-start_call, '[ms]')
   
   // Render the response as XML in reply to the webhook request
-  res.set('Content-Type', 'text/xml');
+  res.set('Content-Type', 'application/xml;');
   res.status(200).send(messageToVXML);
   
 })
@@ -363,6 +370,8 @@ async function getMessage(callSid, from, project_id, conversation_id){
           await tdChannel.removeMessageFromQueue(conversation_id, message._id)
           //reset delayIndex for wait command message time
           await voiceChannel.clearDelayTimeForCallId(callSid)
+          //manage attributes for current callId
+          await voiceChannel.saveSettingsForCallId(message.attributes, callSid)
 
           resolve(message);
           return;
@@ -918,23 +927,16 @@ router.post('/record/:callSid/',async (req, res) => {
     return res.status(404).send({error: "VOICE Channel not already connected"})
   }
   
-  //SPEECH TO TEXT
-  let key = sessionInfo.integrations.find((el => el.type === VOICE_PROVIDER.OPEN_AI))?.key
-  let publicKey = sessionInfo.integrations.find((el => el.type === VOICE_PROVIDER.OPEN_AI))?.publicKey
-  //check quotes if user is using public GPT_KEY
-  if(publicKey){
-    let keep_going = await aiService.checkQuoteAvailability(project_id, user.token);
-    if(!keep_going){
-      //no toke is available
-    }
-  }
   
-  let textMessage = await aiService.speechToText(audioFileUrl, vxmlAttributes.STT_MODEL, key).catch((err)=>{
-    console.log('errr while transcript', err.response?.data)
-  })
-  console.log('(voice) Message captured after STT -->', textMessage)
+  let attributes = await voiceChannel.getSettingsForCallId(callSid);
+  console.log('attributessss', attributes)
   
-  if(!textMessage){
+  //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)
@@ -953,13 +955,7 @@ router.post('/record/:callSid/',async (req, res) => {
     })
   }
   
-  
-  let tiledeskMessage= {
-      text:textMessage,
-      senderFullname: from,
-      type: 'text',
-      channel: { name: CHANNEL_NAME }
-  };
+
   let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
   winston.debug("message sent : ", tdMessage);
   
@@ -979,6 +975,77 @@ router.post('/record/:callSid/',async (req, res) => {
 
 })
 
+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'
+            }
+          };
+
+        }
+      }
+      
+      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= {
+        text: text,
+        senderFullname: sessionInfo.from,
+        type: 'text',
+        channel: { name: CHANNEL_NAME }
+      };
+      break;
+
+  }
+
+  return tiledeskMessage
+}
+
+
 
 router.get('/addon/transcript', async (req, res) => {
   winston.verbose("(vxml) called GET /transcript query-->" , req.query);
@@ -1225,12 +1292,14 @@ async function startApp(settings, callback) {
   if(settings.OPENAI_ENDPOINT){
     OPENAI_ENDPOINT = settings.OPENAI_ENDPOINT
   }
+  if(settings.ELEVENLABS_ENDPOINT){
+    ELEVENLABS_ENDPOINT = settings.ELEVENLABS_ENDPOINT
+  }
   
   if(settings.MAX_POLLING_TIME){
-    MAX_POLLING_TIME = settings.MAX_POLLING_TIME;
+    MAX_POLLING_TIME = settings.MAX_POLLING_TIME/10000; //convert in seconds
   }
   
-  
   if (settings.REDIS_HOST && settings.REDIS_PORT) {
     REDIS_HOST = settings.REDIS_HOST;
     REDIS_PORT = settings.REDIS_PORT;
@@ -1249,6 +1318,7 @@ async function startApp(settings, callback) {
   //init Services
   aiService = new AiService({
     OPENAI_ENDPOINT: OPENAI_ENDPOINT,
+    ELEVENLABS_ENDPOINT: ELEVENLABS_ENDPOINT,
     API_URL: API_URL
   })
   integrationService = new IntegrationService({