@tiledesk/tiledesk-tybot-connector 2.0.35 → 2.0.36-rc12

package/engine/TiledeskChatbot.js

@@ -43,48 +43,60 @@ class TiledeskChatbot {
   }
 
   async replyToMessage(message, callback) {
+    console.log(`(GAB) TiledeskChatbot replyToMessage start -->  at : ${new Date().getTime()} for message.sender: ${message.sender} with text: ${message.text}`)
     return new Promise( async (resolve, reject) => {
       let lead = null;
       if (message.request) {
         this.request = message.request;
       }
       
-      // reset lockedIntent on direct user invocation ( /intent or action => this only?)
+
+      let start00 = new Date();
       if (message.sender != "_tdinternal") {
         try {
-          winston.verbose("(TiledeskChatbot) Checking locked intent reset on action invocation")
-          if (message.attributes && message.attributes.action) {
-            winston.debug("(TiledeskChatbot) Message has action: " + message.attributes.action)
-            await this.unlockIntent(this.requestId);
-            await this.unlockAction(this.requestId);
-            winston.debug("(TiledeskChatbot) Reset locked intent. Intent was explicitly invoked with an action: " + message.attributes.action)
+          winston.verbose("(TiledeskChatbot) External user message, running reset operations…");
+          const ops = [];
+
+          // --- Action/intent reset ---
+          // reset lockedIntent on direct user invocation ( /intent or action => this only?)
+          if (message.attributes?.action) {
+            winston.debug("(TiledeskChatbot) Message has action: " + message.attributes.action);
+            ops.push(this.unlockIntent(this.requestId), this.unlockAction(this.requestId));
+            winston.debug("(TiledeskChatbot) Reset locked intent. Intent was explicitly invoked with an action: " + message.attributes.action);
           }
-        } catch(error) {
-          winston.error("(TiledeskChatbot) Error resetting locked intent: ", error)
-        }
-      }
 
-      // any external invocation restarts the steps counter
-      try {
-        if (message.sender != "_tdinternal") {
+          // --- Steps reset ---
+          // any external invocation restarts the steps counter
           winston.verbose("(TiledeskChatbot) Resetting current step by request message: " + message.text);
-          await TiledeskChatbot.resetStep(this.tdcache, this.requestId);
-          await TiledeskChatbot.resetStarted(this.tdcache, this.requestId);
+          ops.push(
+            TiledeskChatbot.resetStep(this.tdcache, this.requestId),
+            TiledeskChatbot.resetStarted(this.tdcache, this.requestId)
+          );
 
+          await Promise.all(ops);
+
+          // --- Debug final state ---
           if (this.tdcache) {
-            let currentStep = 
-            await TiledeskChatbot.currentStep(this.tdcache, this.requestId);
+            const currentStep = await TiledeskChatbot.currentStep(this.tdcache, this.requestId);
             winston.verbose("(TiledeskChatbot) After reset currentStep:" + currentStep);
           }
-          
+
+        } catch (error) {
+          winston.error("(TiledeskChatbot) Error resetting locked intent: ", error)
         }
-      } catch(error) {
-        winston.error("(TiledeskChatbot) Error resetting locked intent: ", error);
       }
+      let end00 = new Date()
+      console.log(`(GAB) TiledeskChatbot replyToMessage 00--> after reset lockedIntent at :  ${end00.getTime()}, diff: ${end00-start00}[ms]`)
+       
+
 
       // Checking locked intent (for non-internal intents)
       // internal intents always "skip" the locked intent
+      let start0 = new Date()
       const locked_intent = await this.currentLockedIntent(this.requestId);
+      let end0 = new Date()
+      console.log(`(GAB) TiledeskChatbot replyToMessage 0--> after currentLockedIntent at :  ${end0.getTime()}, diff: ${end0-start0}[ms]`)
+        
       winston.verbose("(TiledeskChatbot) Got locked intent: -" + locked_intent + "-");
       if (locked_intent) {
         // const tdclient = new TiledeskClient({
@@ -95,11 +107,18 @@ class TiledeskChatbot {
         // });
         // it only gets the locked_intent
         // const faq = await this.botsDataSource.getByIntentDisplayName(this.botId, locked_intent);
+        let start0 = new Date()
         const faq = await this.botsDataSource.getByIntentDisplayNameCache(this.botId, locked_intent, this.tdcache);
+        let end0 = new Date()
+        console.log(`(GAB) TiledeskChatbot replyToMessage 1-> after botsDataSource.getByIntentDisplayNameCache at :  ${end0.getTime()}, diff: ${end0-start0}[ms]`)
         winston.debug("(TiledeskChatbot) Locked intent. Got faqs: ", faq);
         let reply;
         if (faq) {
+          let start1 = new Date()
           reply = await this.execIntent(faq, message, lead);//, bot);
+          let end1 = new Date()
+          console.log(`(GAB) TiledeskChatbot replyToMessage 1--> after execIntent at :  ${end1.getTime()}, diff: ${end1-start1}[ms]`)
+        
         }
         else {
           reply = {
@@ -148,7 +167,10 @@ class TiledeskChatbot {
         }
         else {
           winston.verbose("(TiledeskChatbot) Processing intent:", explicit_intent_name)
+          let start2 = new Date()
           let faq = await this.botsDataSource.getByIntentDisplayNameCache(this.botId, intent.name, this.tdcache);
+          let end2 = new Date()
+          console.log(`(GAB) TiledeskChatbot replyToMessage 2--> after botsDataSource.getByIntentDisplayNameCache at :  ${end2.getTime()}, diff: ${end2-start2}[ms]`)
           if (faq) {
             winston.verbose("(TiledeskChatbot) Got a reply (faq) by Intent name:", faq)
             try {
@@ -158,7 +180,11 @@ class TiledeskChatbot {
                   this.addParameter(key, value);                  
                 }
               }
+              let start2 = new Date();
               reply = await this.execIntent(faq, message, lead);
+              let end2 = new Date()
+              console.log(`(GAB) TiledeskChatbot replyToMessage 2--> after execIntent at :  ${end2.getTime()}, diff: ${end2-start2}[ms]`)
+        
               resolve(reply);
               return;
             }
@@ -189,7 +215,11 @@ class TiledeskChatbot {
         let reply;
         const faq = faqs[0];
         try {
+          let start3 = new Date();
           reply = await this.execIntent(faq, message, lead);//, bot);
+          let end3 = new Date()
+          console.log(`(GAB) TiledeskChatbot replyToMessage 3--> after execIntent at :  ${end3.getTime()}, diff: ${end3-start3}[ms]`)
+        
         }
         catch(error) {
           winston.error("(TiledeskChatbot) An error occured during exact match execIntent(): ", error);
@@ -217,10 +247,18 @@ class TiledeskChatbot {
         }
         winston.debug("(TiledeskChatbot) NLP intents found: ", intents);
         if (intents && intents.length > 0) {
+          let start2 = new Date();
           let faq = await this.botsDataSource.getByIntentDisplayNameCache(this.botId, intents[0].intent_display_name, this.tdcache);
+          let end2 = new Date()
+          console.log(`(GAB) TiledeskChatbot replyToMessage 4--> after botsDataSource.getByIntentDisplayNameCache in if at :  ${end2.getTime()}, diff: ${end2-start2}[ms]`)
+        
           let reply;
           try {
+            let start3 = new Date();
             reply = await this.execIntent(faq, message, lead);//, bot);
+            let end3 = new Date()
+            console.log(`(GAB) TiledeskChatbot replyToMessage 4--> after execIntent in if at :  ${end3.getTime()}, diff: ${end3-start3}[ms]`)
+        
           }
           catch(error) {
             winston.error("(TiledeskChatbot) An error occurred during NLP decoding: ", error);
@@ -231,7 +269,11 @@ class TiledeskChatbot {
           return;
         }
         else {
+          let start4 = new Date();
           let fallbackIntent = await this.botsDataSource.getByIntentDisplayNameCache(this.botId, "defaultFallback", this.tdcache);
+          let end4 = new Date()
+          console.log(`(GAB) TiledeskChatbot replyToMessage 5--> after execIntent in else at :  ${end4.getTime()}, diff: ${end4-start4}[ms]`)
+        
           if (!fallbackIntent) {
             resolve(null);
             return;
@@ -239,7 +281,11 @@ class TiledeskChatbot {
           else {
             let reply;
             try {
+              let start5 = new Date()
               reply = await this.execIntent(fallbackIntent, message, lead);//, bot);
+              let end5 = new Date()
+              console.log(`(GAB) TiledeskChatbot replyToMessage 5--> after execIntent  at :  ${end5.getTime()}, diff: ${end5-start5}[ms]`)
+        
             }
             catch(error) {
               winston.error("(TiledeskChatbot) An error occurred during defaultFallback: ", error);

package/engine/TiledeskChatbotConst.js

@@ -40,6 +40,8 @@ class TiledeskChatbotConst {
     static REQ_LAST_USER_IMAGE_HEIGHT = 'lastUserImageHeight';
     static REQ_LAST_USER_IMAGE_TYPE = 'lastUserImageType';
     static REQ_LAST_USER_DOCUMENT_URL = 'lastUserDocumentURL';
+    static REQ_LAST_USER_DOCUMENT_AS_ATTACHMENT_URL = 'lastUserDocumentAsAttachmentURL';
+    static REQ_LAST_USER_DOCUMENT_AS_INLINE_URL = 'lastUserDocumentAsInlineURL';
     static REQ_LAST_USER_DOCUMENT_NAME = 'lastUserDocumentName';
     static REQ_LAST_USER_DOCUMENT_TYPE = 'lastUserDocumentType';
     static REQ_EMAIL_ATTACHMENTS_LINK = 'link';

package/index.js

@@ -43,6 +43,7 @@ let staticBots;
 
 router.post('/ext/:botid', async (req, res) => {
   const botId = req.params.botid;
+  console.log(`(GAB) /ext/${botId} 0--> called at : ${new Date().getTime()}`)
   winston.verbose("(tybotRoute) POST /ext/:botid called: " + botId)
   if(!botId || botId === "null" || botId === "undefined"){
     return res.status(400).send({"success": false, error: "Required parameters botid not found. Value is 'null' or 'undefined'"})
@@ -90,6 +91,7 @@ router.post('/ext/:botid', async (req, res) => {
     {EX: 604800} // 7 days
   );
 
+  let start0 = new Date()
   let botsDS;
   if (!staticBots) {
     botsDS = new MongodbBotsDataSource({projectId: projectId, botId: botId});
@@ -98,13 +100,20 @@ router.post('/ext/:botid', async (req, res) => {
   else {
     botsDS = new MockBotsDataSource(staticBots);
   }
+  let end0 = new Date()
+  console.log(`(GAB) /ext/${botId} 1--> after get MongodbBotsDataSource at :  ${end0.getTime()}, diff: ${end0-start0}[ms]`)
+  
   
   // get the bot metadata
+  let start1 = new Date()
   let bot = await botsDS.getBotByIdCache(botId, tdcache).catch((err)=> {
     Promise.reject(err);
     return;
   });
+  let end1 = new Date()
+  console.log(`(GAB) /ext/${botId} 2--> after get botsDS.getBotByIdCache at :  ${end1.getTime()}, diff: ${end1-start1}[ms]`)
   
+  let start2 = new Date()
   let intentsMachine;
   let backupMachine;
   if (!staticBots) {
@@ -115,6 +124,8 @@ router.post('/ext/:botid', async (req, res) => {
   else {
     intentsMachine = {}
   }
+  let end2 = new Date()
+  console.log(`(GAB) /ext/${botId} 3--> after get IntentsMachineFactory.getMachine at :  ${end2.getTime()}, diff: ${end2-start2}[ms]`)
 
   const chatbot = new TiledeskChatbot({
     botsDataSource: botsDS,
@@ -133,14 +144,23 @@ router.post('/ext/:botid', async (req, res) => {
   });
   winston.verbose("(tybotRoute) Message text: " + message.text)
   
+  let start3 = new Date()
   await TiledeskChatbotUtil.updateRequestAttributes(chatbot, token, message, projectId, requestId);
+  let end3 = new Date()
+  console.log(`(GAB) /ext/${botId} 4--> after get TiledeskChatbotUtil.updateRequestAttributes at :  ${end3.getTime()}, diff: ${end3-start3}[ms]`)
   if (requestId.startsWith("support-group-")) {
     await TiledeskChatbotUtil.updateConversationTranscript(chatbot, message);
   }
+  let end4 = new Date()
+  console.log(`(GAB) /ext/${botId} 5--> after get TiledeskChatbotUtil.updateConversationTranscript at :  ${end4.getTime()}, diff: ${end4-end3}[ms]`)
+  
 
   let reply = null;
   try {
+    let start5 = new Date()
     reply = await chatbot.replyToMessage(message);
+    let end5 = new Date()
+    console.log(`(GAB) /ext/${botId} 6--> after chatbot.replyToMessage at :  ${end5.getTime()}, diff: ${end5-start5}[ms]`)
   }
   catch(err) {
     winston.error("(tybotRoute) An error occurred replying to message: ", err);
@@ -151,11 +171,16 @@ router.post('/ext/:botid', async (req, res) => {
     return;
   }
   
+  
   if (reply.actions && reply.actions.length > 0) { // structured actions (coming from chatbot designer)
     try {
+      let start6 = new Date()
       winston.debug("(tybotRoute) Reply actions: ", reply.actions)
       let directives = TiledeskChatbotUtil.actionsToDirectives(reply.actions);
       winston.debug("(tybotRoute) the directives:", directives)
+      let end6 = new Date()
+      console.log(`(GAB) /ext/${botId} 7--> after TiledeskChatbotUtil.actionsToDirectives at :  ${end6.getTime()}, diff: ${end6-start6}[ms]`)
+  
       let directivesPlug = new DirectivesChatbotPlug(
         {
           message: message,
@@ -170,6 +195,7 @@ router.post('/ext/:botid', async (req, res) => {
           cache: tdcache
         }
       );
+      console.log(`(GAB) /ext/${botId} 8--> directivesPlug.processDirectives at :  ${end6.getTime()}`)
       directivesPlug.processDirectives( () => {
         winston.verbose("(tybotRoute) Actions - Directives executed.");
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiledesk/tiledesk-tybot-connector",
-  "version": "2.0.35",
+  "version": "2.0.36-rc12",
   "description": "Tiledesk Tybot connector",
   "main": "index.js",
   "scripts": {

package/tiledeskChatbotPlugs/DirectivesChatbotPlug.js

@@ -117,6 +117,7 @@ class DirectivesChatbotPlug {
   }
 
   async processDirectives(theend) {
+    console.log(`(GAB) DirectivesChatbotPlug 0--> after processDirectives at :  ${new Date().getTime()}`)
     this.theend = theend;
     const directives = this.directives;
     if (!directives || directives.length === 0) {
@@ -170,15 +171,23 @@ class DirectivesChatbotPlug {
     this.curr_directive_index = -1;
     winston.verbose("(DirectivesChatbotPlug) processing directives...");
     
+    let start1 = new Date()
     const next_dir = await this.nextDirective(directives);
+    let end1 = new Date()
+    console.log(`(GAB) DirectivesChatbotPlug 1--> after processDirectives nextDirective at :  ${end1.getTime()}, diff: ${end1-start1}[ms]`)
+  
     winston.debug("(DirectivesChatbotPlug) next_dir: ", next_dir);
     await this.process(next_dir);
   }
 
   async nextDirective(directives) {
+    console.log(`(GAB) DirectivesChatbotPlug 0--> nextDirective at :  ${new Date().getTime()}`)
+    let start1 = new Date()
     winston.debug("(DirectivesChatbotPlug) ....nextDirective() checkStep()");
     const go_on = await TiledeskChatbot.checkStep(this.context.tdcache, this.context.requestId, this.chatbot?.MAX_STEPS,  this.chatbot?.MAX_EXECUTION_TIME);
-
+    let end1 = new Date()
+    console.log(`(GAB) DirectivesChatbotPlug 1--> nextDirective at :  ${end1.getTime()}, diff: ${end1-start1}[ms]`)
+  
     if (go_on.error) {
       winston.debug("(DirectivesChatbotPlug) go_on == false! nextDirective() Stopped!");
       return this.errorMessage(go_on.error); //"Request error: anomaly detection. MAX ACTIONS exeeded.");
@@ -211,6 +220,7 @@ class DirectivesChatbotPlug {
   }
 
   async process(directive) {
+    console.log(`(GAB) DirectivesChatbotPlug process 0--> after process at :  ${new Date().getTime()}`)
     let context = this.context;
     if (directive) {
       winston.verbose("(DirectivesChatbotPlug) directive['name']: " + directive["name"]);
@@ -219,16 +229,23 @@ class DirectivesChatbotPlug {
     if (directive && directive.name) {
       directive_name = directive.name.toLowerCase();
     }
+    let start1 = new Date();
     if (directive && directive.action) {
         const action_id = directive.action["_tdActionId"];
         const locked_action_id = await this.chatbot.currentLockedAction(this.supportRequest.request_id);
+        let end1 = new Date()
+        console.log(`(GAB) DirectivesChatbotPlug process 1--> after chatbot.currentLockedAction at :  ${end1.getTime()}, diff: ${end1-start1}[ms]`)
         if ( locked_action_id && (locked_action_id !== action_id) ) {
+          let start2 = new Date();
           let next_dir = await this.nextDirective(this.directives);
+          let end2 = new Date()
+          console.log(`(GAB) DirectivesChatbotPlug process 2--> after chatbot.currentLockedAction at :  ${end2.getTime()}, diff: ${end2-start2}[ms]`)
           this.process(next_dir);
           return;
         }
       
     }
+    let start2 = new Date()
     if (directive == null || (directive !== null && directive["name"] === undefined)) {
       winston.debug("(DirectivesChatbotPlug) stop process(). directive is (null?): ", directive);
       this.theend();
@@ -450,7 +467,11 @@ class DirectivesChatbotPlug {
       });
     }
     else if (directive_name === Directives.WAIT) {
+      let end2 = new Date();
+      console.log(`(GAB) DirectivesChatbotPlug process 3--> before DirWait execute at :  ${end2.getTime()}`)
       new DirWait(context).execute(directive, async () => {
+        let endWait = new Date()
+        console.log(`(GAB) DirectivesChatbotPlug process 3--> after DirWait executed callback at :  ${endWait.getTime()}, diff: ${endWait-end2}[ms]`)
         let next_dir = await this.nextDirective(this.directives);
         this.process(next_dir);
       });

package/tiledeskChatbotPlugs/directives/DirWait.js

@@ -18,6 +18,7 @@ class DirWait {
   }
 
   execute(directive, callback) {
+    console.log(`(GAB) called DirWait execute at : ${new Date().getTime()}, directive:`, directive)
     //  500ms < wait-time < 10.000ms
     winston.verbose("Execute Wait directive");
     let action;
@@ -47,6 +48,7 @@ class DirWait {
     }
 
     this.go(action, () => {
+      console.log(`(DirWait)  go callback exit at: ${new Date().getTime()} . . .` )
       this.logger.native("[Wait] Executed");
       callback();
     })
@@ -58,10 +60,16 @@ class DirWait {
     // const step_key = TiledeskChatbot.requestCacheKey(this.requestId) + ":step";
     if (action && action.millis >= 1000) {//2000 * 60) { // at list 2 minutes waiting time to reset the steps counter
       // await this.tdcache.set(step_key, 0);
+      let start1= new Date()
       await TiledeskChatbot.resetStep(this.tdcache, this.requestId);
+      let end1 = new Date()
+      console.log(`(GAB) called DirWait go() 1-> after TiledeskChatbot.resetStep at :  ${end1.getTime()}, diff: ${end1-start1}[ms]`)
+       
     }
+    console.log(`(GAB) called DirWait go() at :${new Date().getTime()}, millis: ${action.millis}`)
     this.logger.native("[Wait] Waiting for ", action.millis, "[ms]")
     setTimeout(() => {
+      console.log(`(GAB) called DirWait go() settimeout at : ${new Date().getTime()}`)
       callback();
     }, action.millis);
   }

package/utils/TiledeskChatbotUtil.js

@@ -680,189 +680,172 @@ class TiledeskChatbotUtil {
         // update request context
         try {
             winston.debug("Updating request variables. Message:", message);
-            const messageId = message._id;
+            
 
-            if(process.env.BASE_URL){
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHAT_URL, `${process.env.BASE_URL}/dashboard/#/project/${projectId}/wsrequest/${requestId}/messages`);
+            const addQueue = [];
+            const deleteQueue = [];
+            const add = (k, v) => { if (v !== undefined && v !== null && k !== undefined && k !== null) addQueue.push([k, v]); };
+            const remove = (k) => { if(k) deleteQueue.push(k);}
+
+            // --- BASE ATTRIBUTES ---
+            if (process.env.BASE_URL) {
+                add(TiledeskChatbotConst.REQ_CHAT_URL, `${process.env.BASE_URL}/dashboard/#/project/${projectId}/wsrequest/${requestId}/messages`);
             }
             
-            await chatbot.addParameter(TiledeskChatbotConst.REQ_PROJECT_ID_KEY, projectId);
-            await chatbot.addParameter(TiledeskChatbotConst.REQ_REQUEST_ID_KEY, requestId);
-            
+            add(TiledeskChatbotConst.REQ_PROJECT_ID_KEY, projectId);
+            add(TiledeskChatbotConst.REQ_REQUEST_ID_KEY, requestId);
+
+            // --- CHATBOT INFO ---
             if (chatbot.bot) {
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_NAME_KEY, chatbot.bot.name);
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_ID_KEY, chatbot.bot._id);
-            }
-            
-            if (chatbotToken) {
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_TOKEN, chatbotToken); // DEPRECATED
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_TOKEN_v2, "JWT " + chatbotToken);
+                add(TiledeskChatbotConst.REQ_CHATBOT_NAME_KEY, chatbot.bot.name);
+                add(TiledeskChatbotConst.REQ_CHATBOT_ID_KEY, chatbot.bot._id);
             }
-            
-            if (process.env.TILEDESK_API) {
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_TOKEN, chatbotToken); // DEPRECATED
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_TOKEN_v2, "JWT " + chatbotToken);
+
+            // --- TOKEN ---
+            if (chatbotToken || process.env.TILEDESK_API) {
+                add(TiledeskChatbotConst.REQ_CHATBOT_TOKEN, chatbotToken); // deprecated
+                add(TiledeskChatbotConst.REQ_CHATBOT_TOKEN_v2, "JWT " + chatbotToken);
             }
-            
+
             if (process.env.API_URL) {
-                await chatbot.addParameter(TiledeskChatbotConst.API_BASE_URL, process.env.API_URL);
+                add(TiledeskChatbotConst.API_BASE_URL, process.env.API_URL);
             }
 
+            // --- USER MESSAGE ---
             if (message.text && message.sender !== "_tdinternal") {
-                await chatbot.deleteParameter(TiledeskChatbotConst.USER_INPUT); // user wrote, delete userInput, replyv2 will not trigger timeout action
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_USER_TEXT_KEY, message.text); // DEPRECATED
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_USER_TEXT_v2_KEY, message.text);
+                remove(TiledeskChatbotConst.USER_INPUT); // REAL delete
+    
+                add(TiledeskChatbotConst.REQ_LAST_USER_TEXT_KEY, message.text);  // deprecated
+                add(TiledeskChatbotConst.REQ_LAST_USER_TEXT_v2_KEY, message.text);
+    
+                add(TiledeskChatbotConst.REQ_LAST_USER_MESSAGE_TYPE_KEY, message.type);
+                add(TiledeskChatbotConst.REQ_LAST_USER_MESSAGE_KEY,
+                    TiledeskChatbotUtil.lastUserMessageFrom(message));
+    
                 if (message.channel) {
-                    if (message.channel.name === "chat21") {
-                        await chatbot.addParameter(TiledeskChatbotConst.REQ_CHAT_CHANNEL, "web"); // renames the channel in chat21
-                    }
-                    else {
-                        await chatbot.addParameter(TiledeskChatbotConst.REQ_CHAT_CHANNEL, message.channel.name);
-                    }
+                    const channelName = message.channel.name === "chat21" ? "web" : message.channel.name;
+                    add(TiledeskChatbotConst.REQ_CHAT_CHANNEL, channelName);
                 }
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_USER_MESSAGE_TYPE_KEY, message.type);
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_USER_MESSAGE_KEY, TiledeskChatbotUtil.lastUserMessageFrom(message)); // JSON TYPE *NEW
             }
 
-            // get image
-            if (message.type && message.type === "image" && message.metadata) {
-                if (message.metadata.src) {
-                    await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_USER_IMAGE_URL, message.metadata.src);
-                    await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_USER_IMAGE_NAME, message.metadata.name);
-                    await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_USER_IMAGE_WIDTH, message.metadata.width);
-                    await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_USER_IMAGE_HEIGHT, message.metadata.height);
-                    await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_USER_IMAGE_TYPE, message.metadata.type);
-                }
+            // --- IMAGE ---
+            if (message.type && message.type === "image" && message.metadata?.src) {
+                add(TiledeskChatbotConst.REQ_LAST_USER_IMAGE_URL, message.metadata.src);
+                add(TiledeskChatbotConst.REQ_LAST_USER_IMAGE_NAME, message.metadata.name);
+                add(TiledeskChatbotConst.REQ_LAST_USER_IMAGE_WIDTH, message.metadata.width);
+                add(TiledeskChatbotConst.REQ_LAST_USER_IMAGE_HEIGHT, message.metadata.height);
+                add(TiledeskChatbotConst.REQ_LAST_USER_IMAGE_TYPE, message.metadata.type);
             }
 
-            // get document
-            if (message.type && message.type === "file" && message.metadata) {
-                if (message.metadata.src) {                    
-                    await chatbot.addParameter("lastUserDocumentURL", message.metadata.src); // legacy. will be deprecated
-                    const url_as_attachment = message.metadata.src;
-                    await chatbot.addParameter("lastUserDocumentAsAttachmentURL", url_as_attachment);
-                    let url_inline = url_as_attachment;
-                    if (url_as_attachment.match(/.*\/download.*/)) { // removing "/download" removes the "Content-disposion: attachment" HTTP header
-                        url_inline = url_as_attachment.replace('/download', '/');
-                    }
-                    await chatbot.addParameter("lastUserDocumentAsInlineURL", url_inline);
-                    await chatbot.addParameter("lastUserDocumentName", message.metadata.name);
-                    await chatbot.addParameter("lastUserDocumentType", message.metadata.type);
+            // --- DOCUMENT ---
+            if (message.type && message.type === "file" && message.metadata?.src) {
+
+
+                if (message.metadata.src) {  
+                    const m = message.metadata;
+                    add(TiledeskChatbotConst.REQ_LAST_USER_DOCUMENT_URL, m.src); // deprecated
+                    add(TiledeskChatbotConst.REQ_LAST_USER_DOCUMENT_AS_ATTACHMENT_URL, m.src);
+        
+                    const inlineUrl = m.src.replace("/download", "/");
+                    add(TiledeskChatbotConst.REQ_LAST_USER_DOCUMENT_AS_INLINE_URL, inlineUrl);
+
+                    add(TiledeskChatbotConst.REQ_LAST_USER_DOCUMENT_NAME, m.name);
+                    add(TiledeskChatbotConst.REQ_LAST_USER_DOCUMENT_TYPE, m.type);
                 }
             }
             
+            // --- LEAD ---
             if (message && message.request && message.request.lead) {
                 winston.debug("(TiledeskChatbotUtil) Lead found with email: " + message.request.lead.email + " and lead.fullname " + message.request.lead.fullname);
-                let currentLeadEmail = await chatbot.getParameter(TiledeskChatbotConst.REQ_LEAD_EMAIL_KEY);
-                winston.debug("(TiledeskChatbotUtil) You lead email from attributes: " + currentLeadEmail);
-                if (message.request.lead.email && !currentLeadEmail) {
-                    // worth saving
-                    winston.debug("(TiledeskChatbotUtil) worth saving email");
-                    try {
-                        await chatbot.addParameter(TiledeskChatbotConst.REQ_LEAD_EMAIL_KEY, message.request.lead.email);
-                    }
-                    catch(error) {
-                        winston.error("(TiledeskChatbotUtil) Error on setting userEmail:", error);
-                    }
-                }
-                let currentLeadName = await chatbot.getParameter(TiledeskChatbotConst.REQ_LEAD_USERFULLNAME_KEY);
-                winston.debug("(TiledeskChatbotUtil) You lead email from attributes: " + currentLeadEmail);
-                if (message.request.lead.fullname && !currentLeadName) {
-                    // worth saving
-                    winston.debug("(TiledeskChatbotUtil) worth saving email");
-                    try {
-                        await chatbot.addParameter(TiledeskChatbotConst.REQ_LEAD_USERFULLNAME_KEY, message.request.lead.fullname);
-                    }
-                    catch(error) {
-                        winston.error("(TiledeskChatbotUtil) Error on setting userFullname: ", error);
-                    }
-                }
+                const lead = message.request.lead;
+
+                const savedEmail = await chatbot.getParameter(TiledeskChatbotConst.REQ_LEAD_EMAIL_KEY);
+                if (lead.email && !savedEmail) add(TiledeskChatbotConst.REQ_LEAD_EMAIL_KEY, lead.email);
+
+                const savedName = await chatbot.getParameter(TiledeskChatbotConst.REQ_LEAD_USERFULLNAME_KEY);
+                if (lead.fullname && !savedName) add(TiledeskChatbotConst.REQ_LEAD_USERFULLNAME_KEY, lead.fullname);
 
                 if (message.request.lead.phone) {
-                    await chatbot.addParameter(TiledeskChatbotConst.REQ_USER_PHONE_KEY, message.request.lead.phone);
+                    add(TiledeskChatbotConst.REQ_USER_PHONE_KEY, lead.phone);
                 }
-                if (message.request.lead.lead_id && (message.request.lead.lead_id.startsWith("wab-") || 
-                                                    message.request.lead.lead_id.startsWith("vxml-") ||
-                                                    message.request.lead.lead_id.startsWith(CHANNEL_NAME.VOICE_TWILIO) || 
-                                                    message.request.lead.lead_id.startsWith(CHANNEL_NAME.SMS))) {
-                    const splits = message.request.lead.lead_id.split("-");
-                    if (splits && splits.length > 1) {
-                        await chatbot.addParameter(TiledeskChatbotConst.REQ_CURRENT_PHONE_NUMBER_KEY,splits[1]);
+                if (lead.lead_id) {
+                    const prefixes = ["wab-", "vxml-", CHANNEL_NAME.VOICE_TWILIO, CHANNEL_NAME.SMS];
+                    if (prefixes.some(pref => lead.lead_id.startsWith(pref))) {
+                        const parts = lead.lead_id.split("-");
+                        if (parts[1]) add(TiledeskChatbotConst.REQ_CURRENT_PHONE_NUMBER_KEY, parts[1]);
                     }
                 }
                 if (message.request.lead._id) {
-                    await chatbot.addParameter(TiledeskChatbotConst.REQ_USER_LEAD_ID_KEY, message.request.lead._id);
+                    add(TiledeskChatbotConst.REQ_USER_LEAD_ID_KEY, lead._id);
                 }
                 if (message.request.lead.company) {
-                    await chatbot.addParameter(TiledeskChatbotConst.REQ_USER_COMPANY_KEY, message.request.lead.company);
+                    add(TiledeskChatbotConst.REQ_USER_COMPANY_KEY, lead.company);
                 }
                 if (message.request.ticket_id) {
-                    await chatbot.addParameter(TiledeskChatbotConst.REQ_TICKET_ID_KEY, message.request.ticket_id);
+                    add(TiledeskChatbotConst.REQ_TICKET_ID_KEY, message.request.ticket_id);
                 }
             }
             
-            await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_MESSAGE_ID_KEY, messageId);
+            // --- LAST MESSAGE ID ---
+            const messageId = message._id;
+            add(TiledeskChatbotConst.REQ_LAST_MESSAGE_ID_KEY, messageId);
+            
+            // --- LOCATION ---
             if (message.request && message.request.location && message.request.location.country) {
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_COUNTRY_KEY, message.request.location.country);
+                add(TiledeskChatbotConst.REQ_COUNTRY_KEY, message.request.location.country);
             }
             if (message.request && message.request.location && message.request.location.city) {
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_CITY_KEY, message.request.location.city);
+                add(TiledeskChatbotConst.REQ_CITY_KEY, message.request.location.city);
             }
+
+            // --- USER CONTEXT ---
             if (message.request) {
-                let user_language = message.request["language"];
-                if (message.request["language"]) {
-                    var languages = parser.parse(message.request["language"]);
-                    if (languages && languages.length > 0 && languages[0].code) {
-                        user_language = languages[0].code;
-                    }
+                let userLang = message.request.language;
+                if (userLang) {
+                    const parsed = parser.parse(userLang);
+                    if (parsed?.[0]?.code) userLang = parsed[0].code;
                 }
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_USER_SOURCE_PAGE_KEY, message.request.sourcePage);
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_USER_LANGUAGE_KEY, user_language);
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_USER_AGENT_KEY, message.request.userAgent);
+
+                add(TiledeskChatbotConst.REQ_USER_SOURCE_PAGE_KEY, message.request.sourcePage);
+                add(TiledeskChatbotConst.REQ_USER_LANGUAGE_KEY, userLang);
+                add(TiledeskChatbotConst.REQ_USER_AGENT_KEY, message.request.userAgent);
+
                 if (message.request.attributes && message.request.attributes.decoded_jwt) {
-                    await chatbot.addParameter(TiledeskChatbotConst.REQ_DECODED_JWT_KEY, message.request.attributes.decoded_jwt);
+                    add(TiledeskChatbotConst.REQ_DECODED_JWT_KEY, message.request.attributes.decoded_jwt);
                 }
-                if (message.request.requester) {
-                    if (message.request.requester.isAuthenticated === true) {
-                        await chatbot.addParameter(TiledeskChatbotConst.REQ_REQUESTER_IS_AUTHENTICATED_KEY, true);
-                    }
-                    else {
-                        await chatbot.addParameter(TiledeskChatbotConst.REQ_REQUESTER_IS_AUTHENTICATED_KEY, false);
-                    }
-                }
-            }
-            if (message.request && message.request.department) {
-                // It was an error when getting this from widget message's attributes
-                // await chatbot.addParameter(TiledeskChatbotConst.REQ_DEPARTMENT_ID_KEY, message.attributes.departmentId);
-                // await chatbot.addParameter(TiledeskChatbotConst.REQ_DEPARTMENT_NAME_KEY, message.attributes.departmentName);
-                // get from request.department instead
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_DEPARTMENT_ID_KEY, message.request.department._id);
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_DEPARTMENT_NAME_KEY, message.request.department.name);
+                
+                const auth = !!message.request.requester?.isAuthenticated;
+                add(TiledeskChatbotConst.REQ_REQUESTER_IS_AUTHENTICATED_KEY, auth);
             }
-            else if (message.attributes && message.attributes.departmentId) {
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_DEPARTMENT_ID_KEY, message.attributes.departmentId);
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_DEPARTMENT_NAME_KEY, message.attributes.departmentName);
+
+            // --- DEPARTMENT ---
+            const dep = message.request?.department || message.attributes;
+            if (dep) {
+                add(TiledeskChatbotConst.REQ_DEPARTMENT_ID_KEY, dep.departmentId || dep._id);
+                add(TiledeskChatbotConst.REQ_DEPARTMENT_NAME_KEY, dep.departmentName || dep.name);
             }
 
+            // --- EMAIL ATTRIBUTES ---
             if (message.attributes) {
-                const attrFields = [
-                    { key: TiledeskChatbotConst.REQ_EMAIL_SUBJECT, attr:  "email_subject" },
-                    { key: TiledeskChatbotConst.REQ_EMAIL_TO, attr: "email_toEmail" },
-                    { key: TiledeskChatbotConst.REQ_EMAIL_FROM, attr: "email_fromEmail" },
-                    { key: TiledeskChatbotConst.REQ_EMAIL_MESSAGE_ID, attr: "email_messageId" },
-                    { key: TiledeskChatbotConst.REQ_EMAIL_REPLY_TO, attr: "email_replyTo" },
-                    { key: TiledeskChatbotConst.REQ_EMAIL_EML, attr: "email_eml" },
-                    { key: TiledeskChatbotConst.REQ_EMAIL_ATTACHMENTS_LINK, attr: "link" },
-                    { key: TiledeskChatbotConst.REQ_EMAIL_ATTACHMENTS_FILES, attr: "attachments" },
-                    // aggiungi qui altri campi se necessario
+                const emailMapping = [
+                    ["email_subject", TiledeskChatbotConst.REQ_EMAIL_SUBJECT],
+                    ["email_toEmail", TiledeskChatbotConst.REQ_EMAIL_TO],
+                    ["email_fromEmail", TiledeskChatbotConst.REQ_EMAIL_FROM],
+                    ["email_messageId", TiledeskChatbotConst.REQ_EMAIL_MESSAGE_ID],
+                    ["email_replyTo", TiledeskChatbotConst.REQ_EMAIL_REPLY_TO],
+                    ["email_eml", TiledeskChatbotConst.REQ_EMAIL_EML],
+                    ["link", TiledeskChatbotConst.REQ_EMAIL_ATTACHMENTS_LINK],
+                    ["attachments", TiledeskChatbotConst.REQ_EMAIL_ATTACHMENTS_FILES]
                 ];
-                for (const field of attrFields) {
-                    if (message.attributes[field.attr] !== undefined && message.attributes[field.attr] !== null) {
-                        await chatbot.addParameter(field.key, message.attributes[field.attr]);
+    
+                for (const [attr, key] of emailMapping) {
+                    if (message.attributes[attr] !== undefined) {
+                        add(key, message.attributes[attr]);
                     }
                 }
             }
 
+            // --- PAYLOAD ---
             if (message && message.request && message.request.attributes && message.request.attributes.payload) {
                 if (!message.attributes) {
                     message.attributes = {}
@@ -873,15 +856,15 @@ class TiledeskChatbotUtil {
             if (message.attributes) {
                 winston.debug("(TiledeskChatbotUtil) Ok message.attributes ", message.attributes);
 
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_END_USER_ID_KEY, message.attributes.requester_id);
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_END_USER_IP_ADDRESS_KEY, message.attributes.ipAddress);
+                add(TiledeskChatbotConst.REQ_END_USER_ID_KEY, message.attributes.requester_id);
+                add(TiledeskChatbotConst.REQ_END_USER_IP_ADDRESS_KEY, message.attributes.ipAddress);
                 if (message.attributes.payload) {
                     try {
                         for (const [key, value] of Object.entries(message.attributes.payload)) {
                             const value_type = typeof value;
-                            await chatbot.addParameter(key, value);
+                            add(key, value);
                         }
-                        await chatbot.addParameter("payload", message.attributes.payload);
+                        add("payload", message.attributes.payload);
                     }
                     catch(err) {
                         winston.error("(TiledeskChatbotUtil) Error importing message payload in request variables: ", err);
@@ -891,19 +874,19 @@ class TiledeskChatbotUtil {
                 // TODO - REMOVE - THEY ARE IN ATTRIBUTES.PAYLOAD
                 // voice-vxml attributes
                 if (message.attributes.dnis) {
-                    await chatbot.addParameter("dnis", message.attributes.dnis);
+                    add("dnis", message.attributes.dnis);
                 }
                 if (message.attributes.callId) {
-                    await chatbot.addParameter("callId", message.attributes.callId);
+                    add("callId", message.attributes.callId);
                 }
                 if (message.attributes.ani) {
-                    await chatbot.addParameter("ani", message.attributes.ani);
+                    add("ani", message.attributes.ani);
                 }
             }
 
             
             
-            
+            // --- GLOBALS ---
             const _bot = chatbot.bot; // aka FaqKB
             winston.debug("(TiledeskChatbotUtil) Adding Globals to context: ", _bot); 
             
@@ -911,7 +894,7 @@ class TiledeskChatbotUtil {
                 winston.debug("(TiledeskChatbotUtil) Got Globals: ", _bot.attributes.globals);
                 _bot.attributes.globals.forEach(async (global_var) => {
                     winston.error("(TiledeskChatbotUtil) Adding global: " + global_var.key + " value: " + global_var.value);
-                    await chatbot.addParameter(global_var.key, global_var.value);
+                    add(global_var.key, global_var.value);
                 });
             }
             // await chatbot.addParameter("testVar",
@@ -922,6 +905,13 @@ class TiledeskChatbotUtil {
             //         }
             //     }
             // );
+
+            
+            // --- FINAL BATCH EXECUTION ---
+            await Promise.all([
+                ...addQueue.map(([key, value]) => chatbot.addParameter(key, value)),
+                ...deleteQueue.map(key => chatbot.deleteParameter(key))
+            ]);
             
         } catch(error) {
             winston.error("(TiledeskChatbotUtil) updateRequestAttributes Error: ", error);
@@ -951,28 +941,14 @@ class TiledeskChatbotUtil {
     }
 
     static validateRequestId(requestId, projectId) {
-        let isValid = false;
-        if (requestId.startsWith("support-group-")) {
-            const parts = requestId.split("-");
-            if (parts.length >= 4) {
-                isValid = (parts[0] === "support" && parts[1] === "group" && parts[2] === projectId && parts[3].length > 0);
-            }
-            else {
-                isValid = false;
-            }
-        } else if (requestId.startsWith("automation-request-")) {
-            const parts = requestId.split("-");
-            if (parts.length === 4 || parts.length === 5) {
-                isValid = (parts[0] === "automation" && parts[1] === "request" && parts[2] === projectId && parts[3].length > 0);
-            }
-            else {
-                isValid = false;
-            }
-        }
-        else {
-            isValid = false;
-        }
-        return isValid;
+        if (!requestId || !projectId) return false;
+
+        // Pattern for support-group-{projectId}-{id}
+        const supportPattern = new RegExp(`^support-group-${projectId}-\\S+$`);
+        // Pattern for automation-request-{projectId}-{id} or automation-request-{projectId}-{id}-something
+        const automationPattern = new RegExp(`^automation-request-${projectId}-\\S+(-\\S+)?$`);
+
+        return supportPattern.test(requestId) || automationPattern.test(requestId);
     }
 
     static userFlowAttributes(flowAttributes) {