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

package/tiledeskChatbotPlugs/directives/DirSendEmail.js

@@ -1,5 +1,4 @@
 const { param } = require('express/lib/request');
-const ms = require('minimist-string');
 const { TiledeskChatbot } = require('../../engine/TiledeskChatbot');
 const { Filler } = require('../Filler');
 const { TiledeskClient } = require('@tiledesk/tiledesk-client');
@@ -27,16 +26,7 @@ class DirSendEmail {
     let action;
     if (directive.action) {
       action = directive.action;
-    }
-    else if (directive.parameter && directive.parameter.trim() !== "") {
-      const params = this.parseParams(directive.parameter);
-      action = {
-        subject: params.subject,
-        text: params.text,
-        to: params.to
-      }
-    }
-    else {
+    } else {
       this.logger.error("Incorrect action for ", directive.name, directive)
       winston.warn("DirSendEmail Incorrect directive: ", directive);
       callback();
@@ -94,27 +84,6 @@ class DirSendEmail {
         }
       }
   }
-
-  parseParams(directive_parameter) {
-    let subject = null;
-    let text = null;
-    let to = null
-    const params = ms(directive_parameter);
-    if (params.subject) {
-      subject = params.subject
-    }
-    if (params.text) {
-      text = params.text.replace(/\\n/g, "\n");
-    }
-    if (params.to) {
-      to = params.to;
-    }
-    return {
-      subject: subject,
-      to: to,
-      text: text
-    }
-  }
 }
 
 module.exports = { DirSendEmail };

package/tiledeskChatbotPlugs/directives/DirWait.js

@@ -18,7 +18,6 @@ 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;
@@ -48,7 +47,6 @@ class DirWait {
     }
 
     this.go(action, () => {
-      console.log(`(DirWait)  go callback exit at: ${new Date().getTime()} . . .` )
       this.logger.native("[Wait] Executed");
       callback();
     })
@@ -60,16 +58,10 @@ 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,172 +680,189 @@ class TiledeskChatbotUtil {
         // update request context
         try {
             winston.debug("Updating request variables. Message:", message);
-            
-
-            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);}
+            const messageId = message._id;
 
-            // --- BASE ATTRIBUTES ---
-            if (process.env.BASE_URL) {
-                add(TiledeskChatbotConst.REQ_CHAT_URL, `${process.env.BASE_URL}/dashboard/#/project/${projectId}/wsrequest/${requestId}/messages`);
+            if(process.env.BASE_URL){
+                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHAT_URL, `${process.env.BASE_URL}/dashboard/#/project/${projectId}/wsrequest/${requestId}/messages`);
             }
             
-            add(TiledeskChatbotConst.REQ_PROJECT_ID_KEY, projectId);
-            add(TiledeskChatbotConst.REQ_REQUEST_ID_KEY, requestId);
-
-            // --- CHATBOT INFO ---
+            await chatbot.addParameter(TiledeskChatbotConst.REQ_PROJECT_ID_KEY, projectId);
+            await chatbot.addParameter(TiledeskChatbotConst.REQ_REQUEST_ID_KEY, requestId);
+            
             if (chatbot.bot) {
-                add(TiledeskChatbotConst.REQ_CHATBOT_NAME_KEY, chatbot.bot.name);
-                add(TiledeskChatbotConst.REQ_CHATBOT_ID_KEY, chatbot.bot._id);
+                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_NAME_KEY, chatbot.bot.name);
+                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_ID_KEY, chatbot.bot._id);
             }
-
-            // --- TOKEN ---
-            if (chatbotToken || process.env.TILEDESK_API) {
-                add(TiledeskChatbotConst.REQ_CHATBOT_TOKEN, chatbotToken); // deprecated
-                add(TiledeskChatbotConst.REQ_CHATBOT_TOKEN_v2, "JWT " + chatbotToken);
+            
+            if (chatbotToken) {
+                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_TOKEN, chatbotToken); // DEPRECATED
+                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_TOKEN_v2, "JWT " + chatbotToken);
             }
-
+            
+            if (process.env.TILEDESK_API) {
+                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_TOKEN, chatbotToken); // DEPRECATED
+                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_TOKEN_v2, "JWT " + chatbotToken);
+            }
+            
             if (process.env.API_URL) {
-                add(TiledeskChatbotConst.API_BASE_URL, process.env.API_URL);
+                await chatbot.addParameter(TiledeskChatbotConst.API_BASE_URL, process.env.API_URL);
             }
 
-            // --- USER MESSAGE ---
             if (message.text && message.sender !== "_tdinternal") {
-                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));
-    
+                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);
                 if (message.channel) {
-                    const channelName = message.channel.name === "chat21" ? "web" : message.channel.name;
-                    add(TiledeskChatbotConst.REQ_CHAT_CHANNEL, channelName);
+                    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);
+                    }
                 }
+                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
             }
 
-            // --- 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 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);
+                }
             }
 
-            // --- 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);
+            // 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);
                 }
             }
             
-            // --- 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);
-                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);
+                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);
+                    }
+                }
 
                 if (message.request.lead.phone) {
-                    add(TiledeskChatbotConst.REQ_USER_PHONE_KEY, lead.phone);
+                    await chatbot.addParameter(TiledeskChatbotConst.REQ_USER_PHONE_KEY, message.request.lead.phone);
                 }
-                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.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 (message.request.lead._id) {
-                    add(TiledeskChatbotConst.REQ_USER_LEAD_ID_KEY, lead._id);
+                    await chatbot.addParameter(TiledeskChatbotConst.REQ_USER_LEAD_ID_KEY, message.request.lead._id);
                 }
                 if (message.request.lead.company) {
-                    add(TiledeskChatbotConst.REQ_USER_COMPANY_KEY, lead.company);
+                    await chatbot.addParameter(TiledeskChatbotConst.REQ_USER_COMPANY_KEY, message.request.lead.company);
                 }
                 if (message.request.ticket_id) {
-                    add(TiledeskChatbotConst.REQ_TICKET_ID_KEY, message.request.ticket_id);
+                    await chatbot.addParameter(TiledeskChatbotConst.REQ_TICKET_ID_KEY, message.request.ticket_id);
                 }
             }
             
-            // --- LAST MESSAGE ID ---
-            const messageId = message._id;
-            add(TiledeskChatbotConst.REQ_LAST_MESSAGE_ID_KEY, messageId);
-            
-            // --- LOCATION ---
+            await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_MESSAGE_ID_KEY, messageId);
             if (message.request && message.request.location && message.request.location.country) {
-                add(TiledeskChatbotConst.REQ_COUNTRY_KEY, message.request.location.country);
+                await chatbot.addParameter(TiledeskChatbotConst.REQ_COUNTRY_KEY, message.request.location.country);
             }
             if (message.request && message.request.location && message.request.location.city) {
-                add(TiledeskChatbotConst.REQ_CITY_KEY, message.request.location.city);
+                await chatbot.addParameter(TiledeskChatbotConst.REQ_CITY_KEY, message.request.location.city);
             }
-
-            // --- USER CONTEXT ---
             if (message.request) {
-                let userLang = message.request.language;
-                if (userLang) {
-                    const parsed = parser.parse(userLang);
-                    if (parsed?.[0]?.code) userLang = parsed[0].code;
+                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;
+                    }
                 }
-
-                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);
-
+                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);
                 if (message.request.attributes && message.request.attributes.decoded_jwt) {
-                    add(TiledeskChatbotConst.REQ_DECODED_JWT_KEY, message.request.attributes.decoded_jwt);
+                    await chatbot.addParameter(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);
+                    }
                 }
-                
-                const auth = !!message.request.requester?.isAuthenticated;
-                add(TiledeskChatbotConst.REQ_REQUESTER_IS_AUTHENTICATED_KEY, auth);
             }
-
-            // --- 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);
+            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);
+            }
+            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);
             }
 
-            // --- EMAIL ATTRIBUTES ---
             if (message.attributes) {
-                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]
+                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
                 ];
-    
-                for (const [attr, key] of emailMapping) {
-                    if (message.attributes[attr] !== undefined) {
-                        add(key, message.attributes[attr]);
+                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]);
                     }
                 }
             }
 
-            // --- PAYLOAD ---
             if (message && message.request && message.request.attributes && message.request.attributes.payload) {
                 if (!message.attributes) {
                     message.attributes = {}
@@ -856,15 +873,15 @@ class TiledeskChatbotUtil {
             if (message.attributes) {
                 winston.debug("(TiledeskChatbotUtil) Ok message.attributes ", message.attributes);
 
-                add(TiledeskChatbotConst.REQ_END_USER_ID_KEY, message.attributes.requester_id);
-                add(TiledeskChatbotConst.REQ_END_USER_IP_ADDRESS_KEY, message.attributes.ipAddress);
+                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);
                 if (message.attributes.payload) {
                     try {
                         for (const [key, value] of Object.entries(message.attributes.payload)) {
                             const value_type = typeof value;
-                            add(key, value);
+                            await chatbot.addParameter(key, value);
                         }
-                        add("payload", message.attributes.payload);
+                        await chatbot.addParameter("payload", message.attributes.payload);
                     }
                     catch(err) {
                         winston.error("(TiledeskChatbotUtil) Error importing message payload in request variables: ", err);
@@ -874,19 +891,19 @@ class TiledeskChatbotUtil {
                 // TODO - REMOVE - THEY ARE IN ATTRIBUTES.PAYLOAD
                 // voice-vxml attributes
                 if (message.attributes.dnis) {
-                    add("dnis", message.attributes.dnis);
+                    await chatbot.addParameter("dnis", message.attributes.dnis);
                 }
                 if (message.attributes.callId) {
-                    add("callId", message.attributes.callId);
+                    await chatbot.addParameter("callId", message.attributes.callId);
                 }
                 if (message.attributes.ani) {
-                    add("ani", message.attributes.ani);
+                    await chatbot.addParameter("ani", message.attributes.ani);
                 }
             }
 
             
             
-            // --- GLOBALS ---
+            
             const _bot = chatbot.bot; // aka FaqKB
             winston.debug("(TiledeskChatbotUtil) Adding Globals to context: ", _bot); 
             
@@ -894,7 +911,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);
-                    add(global_var.key, global_var.value);
+                    await chatbot.addParameter(global_var.key, global_var.value);
                 });
             }
             // await chatbot.addParameter("testVar",
@@ -905,13 +922,6 @@ 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);
@@ -941,14 +951,28 @@ class TiledeskChatbotUtil {
     }
 
     static validateRequestId(requestId, projectId) {
-        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);
+        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;
     }
 
     static userFlowAttributes(flowAttributes) {