@tiledesk/tiledesk-tybot-connector 0.1.48 → 0.1.49

package/.env

@@ -6,4 +6,4 @@ TYBOT_ENDPOINT=http://localhost:10001
 _TYBOT_ENDPOINT=http://localhost:3000
 CHATBOT_TOKEN=JWT eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ3ZWJob29rX2VuYWJsZWQiOmZhbHNlLCJ0eXBlIjoiZXh0ZXJuYWwiLCJsYW5ndWFnZSI6ImVuIiwicHVibGljIjpmYWxzZSwiX2lkIjoiNjM4Yzc5MDQxZGI0NDkwMDM1MTEwMjYwIiwibmFtZSI6IlRoZSBGb3JtIHYyIC0gZXh0IiwidXJsIjoiaHR0cHM6Ly90aWxlYm90LWRldi5oZXJva3VhcHAuY29tL2V4dC82MzhjNzhkNzFkYjQ0OTAwMzUxMTAxYzIiLCJpZF9wcm9qZWN0IjoiNjM4Yzc4YTYxZGI0NDkwMDM1MTBmZjkxIiwidHJhc2hlZCI6ZmFsc2UsImNyZWF0ZWRCeSI6IjVlMDlkMTZkNGQzNjExMDAxNzUwNmQ3ZiIsImNyZWF0ZWRBdCI6IjIwMjItMTItMDRUMTA6NDA6MDQuMjA3WiIsInVwZGF0ZWRBdCI6IjIwMjItMTItMDVUMDc6MjE6MDIuOTIxWiIsIl9fdiI6MCwiZGVzY3JpcHRpb24iOiJPbiBIZXJva3UiLCJpYXQiOjE2NzA2NzE4ODksImF1ZCI6Imh0dHBzOi8vdGlsZWRlc2suY29tL2JvdHMvNjM4Yzc5MDQxZGI0NDkwMDM1MTEwMjYwIiwiaXNzIjoiaHR0cHM6Ly90aWxlZGVzay5jb20iLCJzdWIiOiJib3QiLCJqdGkiOiJmNDVlZGIwYS0zNzVhLTQ0NjMtYjFhZi1jM2ZiZDg4YmE3ZGQifQ.FbW3csHl1sQgSyRz5Jg0qaTvvpXWXgWHlJ1JWoVbv3s
 _CHATBOT_ENDPOINT=http://localhost:10001
-API_LOG=1
+_API_LOG=1

package/CHANGELOG.md

@@ -5,9 +5,14 @@
 available on:
  ▶️ https://www.npmjs.com/package/@tiledesk/tiledesk-tybot-connector
 
+### 0.1.49
+- anomaly detection
+- bug fix
+
 ### 0.1.48
 - fixed ReplaceBot "log" bug
 - ReplaceBot fill-variables botName
+- fixing
 
 ### 0.1.47
 - Introduced _tdIfOnlineAgents --trueIntent -- falseIntent

package/TdCache.js

@@ -72,6 +72,21 @@ class TdCache {
       });
     }
 
+    async incr(key) {
+      // console.log("incr key:", key)
+      return new Promise( async (resolve, reject) => {
+          try {
+            // console.log("incr here...key", key)
+            await this.client.incr(key);
+          }
+          catch(error) {
+            console.error("Error on incr:", error);
+            reject(error)
+          }
+        return resolve();
+      });
+    }
+
     async hset(dict_key, key, value, options) {
       //console.log("hsetting dict_key key value", dict_key, key, value)
       return new Promise( async (resolve, reject) => {

package/index.js

@@ -212,10 +212,12 @@ async function updateRequestVariables(chatbot, message, projectId, requestId) {
   if (message.request && message.request.location && message.request.location.city) {
     await chatbot.addParameter("_tdCity", message.request.location.city);
   }
-  await chatbot.addParameter("_tdRequestSourcePage", message.sourcePage);
-  await chatbot.addParameter("_tdRequestLanguage", message.language);
-  await chatbot.addParameter("_tdRequestUserAgent", message.userAgent);
-  
+  // console.log("message.request.language", message.request["language"])
+  if (message.request) {
+    await chatbot.addParameter("_tdUserSourcePage", message.request.sourcePage);
+    await chatbot.addParameter("_tdUserLanguage", message.request["language"]);
+    await chatbot.addParameter("_tdUserAgent", message.request.userAgent);
+  }
   if (message.attributes) {
     await chatbot.addParameter("_tdRequestDepartmentId", message.attributes.departmentId);
     await chatbot.addParameter("_tdRequestDepartmentName", message.attributes.departmentName);

package/models/MockTdCache.js

@@ -7,14 +7,38 @@ class MockTdCache {
     this.db = new Map();
   }
 
-  set(k, v) {
+  async set(k, v) {
     return new Promise( (resolve, reject) => {
         this.db.set(k, "" + v) // saves as string
         resolve();
     });
   }
 
-  get(k) {
+  async incr(k) {
+    // console.log("incr...", k)
+    // return new Promise( (resolve, reject) => {
+    // console.log("Promise incr...", k)
+    let value = await this.get(k);
+    // console.log("value.............", value)
+    if (value == undefined || value == null) {
+      value = 0;
+    }
+    try {
+      value = Number(value);
+    }
+    catch(error) {
+      // console.error("Error on value = Number(value);", error);
+      value = 0
+    }
+    // console.log("got", k, value)
+    let v_incr = Number(value) + 1;
+    this.db.set(k, "" + v_incr) // saves as string
+    // resolve();
+      
+    // });
+  }
+
+  async get(k) {
     return new Promise( (resolve, reject) => {
         const v = this.db.get(k);
         resolve(v);

package/models/TiledeskChatbot.js

@@ -64,8 +64,23 @@ class TiledeskChatbot {
       }
       
       // any external invocation restarts the steps counter
-      // if (message.sender != "_tdinternal") {
-      //   await TiledeskChatbot.resetStep(this.tdcache, this.requestId);
+      if (message.sender != "_tdinternal") {
+        if (this.log) {
+          console.log("Resetting current step by request message:", message.text);
+        }
+        await TiledeskChatbot.resetStep(this.tdcache, this.requestId);
+        if (this.log) {
+          if (this.tdcache) {
+            let currentStep = 
+            await TiledeskChatbot.currentStep(this.tdcache, this.requestId);
+            if (this.log) {console.log("after reset currentStep:", currentStep)}
+          }
+        }
+      }
+      // Emergency stop :)
+      // if (message.text === "/anomaly") {
+      //   console.log(".................stop on /anomaly!");
+      //   resolve(null);
       // }
 
       // Checking locked intent (for non-internal intents)
@@ -132,6 +147,7 @@ class TiledeskChatbot {
         if (this.log) {console.log("Processing explicit intent:", explicit_intent_name)}
         // look for parameters
         const intent = TiledeskChatbotUtil.parseIntent(explicit_intent_name);
+        if (this.log) {console.log("parsed intent:", intent);}
         let reply;
         if (!intent || (intent && !intent.name)) {
           if (this.log) {console.log("Invalid intent:", explicit_intent_name);}
@@ -217,7 +233,6 @@ class TiledeskChatbot {
         else {
           // fallback
           let fallbackIntent = await this.botsDataSource.getByIntentDisplayName(this.botId, "defaultFallback");
-          console.log("fallbackIntent found", fallbackIntent);
           if (!fallbackIntent) {
             console.log("No defaultFallback found!");
             resolve(null);
@@ -459,33 +474,56 @@ class TiledeskChatbot {
   }
 
   static async checkStep(_tdcache, requestId, max_steps) {
-    let go_on = true;
+    // console.log("CHECKING ON MAX_STEPS:", max_steps);
+    let go_on = true; // continue
     const parameter_key = TiledeskChatbot.requestCacheKey(requestId) + ":step";
-    console.log("parameter_key:", parameter_key);
+    // console.log("__parameter_key:", parameter_key);
+    await _tdcache.incr(parameter_key);
+    // console.log("incr-ed");
     let _current_step = await _tdcache.get(parameter_key);
-    if (!_current_step) { // this shouldn't be happening
-      _current_step = 0;
-    }
-    console.log("_current_step:", _current_step);
+    // if (!_current_step) { // this shouldn't be happening
+    //   _current_step = 0;
+    // }
     let current_step = Number(_current_step);
-    console.log("current_step:", current_step);
-    if (current_step > max_steps) {
-      console.log("current_step > max_steps!", current_step);
-      await TiledeskChatbot.resetStep(_tdcache, requestId);
-      go_on = false;
+    // current_step += 1;
+    // await _tdcache.set(parameter_key, current_step); // increment step
+    // console.log("CURRENT-STEP:", current_step);
+    if (current_step > max_steps) { // max_steps limit just violated
+      // console.log("CURRENT-STEP > MAX_STEPS!", current_step);
+      // await TiledeskChatbot.resetStep(_tdcache, requestId);
+      // go_on = 1; // stop execution, send error message
+      go_on = false
     }
+    // else if (current_step > max_steps + 1) { // max_steps limit already violated
+    //   console.log("CURRENT-STEP > MAX_STEPS!", current_step);
+    //   // await TiledeskChatbot.resetStep(_tdcache, requestId);
+    //   go_on = 2; // stop execution, don't send error message (already sent with go_on = 1)
+    // }
     else {
-      console.log("current_step < max_steps :)", current_step);
-      current_step += 1;
-      await _tdcache.set(parameter_key, current_step); // increment step
-      console.log("current_step from cache:", await _tdcache.get(parameter_key));
+      // go_on = 0;
+      go_on = true;
     }
+    // else {
+      // console.log("CURRENT-STEP UNDER MAX_STEPS THRESHOLD:)", current_step);
+      // current_step += 1;
+      // await _tdcache.set(parameter_key, current_step); // increment step
+      // console.log("current_step from cache:", await _tdcache.get(parameter_key));
+    // }
     return go_on;
   }
 
   static async resetStep(_tdcache, requestId) {
     const parameter_key = TiledeskChatbot.requestCacheKey(requestId) + ":step";
-    await _tdcache.set(parameter_key, 0);
+    // console.log("resetStep() parameter_key:", parameter_key);
+    if (_tdcache) {
+      await _tdcache.set(parameter_key, 0);
+    }
+  }
+
+  static async currentStep(_tdcache, requestId) {
+    const parameter_key = TiledeskChatbot.requestCacheKey(requestId) + ":step";
+    // console.log("currentStep() parameter_key:", parameter_key);
+    return await _tdcache.get(parameter_key);
   }
 
   async allParameters() {

package/models/TiledeskChatbotUtil.js

@@ -28,6 +28,22 @@ class TiledeskChatbotUtil {
         return intent;
 
     }
+
+    // static errorMessage(message) {
+    //     return {
+    //         name: "message",
+    //         action: {
+    //             "_tdThenStop": true,
+    //             text: message,
+    //             attributes: {
+    //                 runtimeError: {
+    //                     message: message
+    //                 }
+    //             }
+    //         }
+    //     }
+    // }
+
 }
 
 module.exports = { TiledeskChatbotUtil };

package/package.json

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

package/test/{anomaly-detection-test.js_ → anomaly-detection-test.js}

@@ -47,25 +47,25 @@ describe('Conversation for anomaly detection test', async () => {
 
   after(function (done) {
     app_listener.close(() => {
-      // console.log('ACTIONS app_listener closed.');
       done();
     });
   });
 
   it('/anomaly', (done) => {
-    console.log("/anomaly story...");
+    // console.log("/anomaly story...");
     let message_id = uuidv4();
     let listener;
     let endpointServer = express();
     endpointServer.use(bodyParser.json());
     endpointServer.post('/:projectId/requests/:requestId/messages', function (req, res) {
-      console.log("...req.body:", JSON.stringify(req.body));
+      // console.log("...req.body:", JSON.stringify(req.body));
       res.send({ success: true });
       const message = req.body;
       assert(message.attributes.error !== null);
-      assert(message.attributes.error.message !== null);
-      assert(message.attributes.error.message === "Request anomaly detection");
+      assert(message.attributes.runtimeError.message === "Request error: anomaly detection. MAX ACTIONS exeeded.");
+      // console.log("/anomaly test success");
       listener.close(() => {
+        // console.log("/anomaly lister test closed");
         done();
       });
     });
@@ -89,7 +89,7 @@ describe('Conversation for anomaly detection test', async () => {
         "token": CHATBOT_TOKEN
       }
       sendMessageToBot(request, BOT_ID, () => {
-        console.log("Message sent:\n", request);
+        // console.log("Message sent:\n", request);
       });
     });
 

package/test/check_steps_test.js

@@ -12,15 +12,12 @@ describe('checkStep()', function() {
     let i;
     // trying to brute-pass MAX_STEPS limit by doubling it
     for (i = 0; i < MAX_STEPS * 2; i++) {
-      console.log("i: " + i);
       let go_on = await TiledeskChatbot.checkStep(tdcache, requestId, MAX_STEPS);
-      console.log("go on?", go_on);
       if (!go_on) {
         break;
       }
     }
-    console.log("last i: " + i);
-    assert(i === MAX_STEPS + 1);
+    assert(i === MAX_STEPS);
   });
   
 });

package/test/conversation-actions_bot.js

@@ -206,11 +206,13 @@ const bot = {
         "webhook_enabled": false,
         "enabled": true,
         "question": "***",
-        "answer": "***",
-        "actions": [{
-            "_tdActionType": "intent",
-            "intentName": "anomaly"
-        }],
+        "actions": [
+            
+            {
+                "_tdActionType": "intent",
+                "intentName": "anomaly"
+            }
+        ],
         "language": "en",
         "intent_display_name": "anomaly"
     }]

package/test/conversation-locked-intent-test.js

@@ -65,7 +65,7 @@ describe('Conversation1 - Form filling', async () => {
       res.send({ success: true });
       const message = req.body;
       if (message.text.startsWith("Hi welcome to this dialog.")) {
-        console.log("got #0 sending #1", message.text);
+        // console.log("got #0 sending #1", message.text);
         let request = {
           "payload": {
             "_id": request1_uuid,
@@ -87,7 +87,7 @@ describe('Conversation1 - Form filling', async () => {
         });
       }
       else if (message.text.startsWith("As I told you,")) {
-        console.log("got #1 sending #2", message.text);
+        // console.log("got #1 sending #2", message.text);
         let request = {
           "payload": {
             "_id": request2_uuid,
@@ -109,7 +109,7 @@ describe('Conversation1 - Form filling', async () => {
         });
       }
       else if (message.text.startsWith("And now tell me,")) {
-        console.log("got #2 sending #3", message.text);
+        // console.log("got #2 sending #3", message.text);
         let request = {
           "payload": {
             "_id": request3_uuid,

package/tiledeskChatbotPlugs/DirectivesChatbotPlug.js

@@ -83,12 +83,13 @@ class DirectivesChatbotPlug {
 
   }
 
-  processDirectives(theend) {
+  async processDirectives(theend) {
     // console.log("Directives to process:", JSON.stringify(this.directives));
+    this.theend = theend;
     const directives = this.directives;
     if (!directives || directives.length === 0) {
       if (this.log) { console.log("No directives to process."); }
-      theend();
+      this.theend();
       return;
     }
     const supportRequest = this.supportRequest;
@@ -96,7 +97,7 @@ class DirectivesChatbotPlug {
     const API_URL = this.API_URL;
     const TILEBOT_ENDPOINT = this.TILEBOT_ENDPOINT;
 
-    const requestId = supportRequest.request_id
+    // const requestId = supportRequest.request_id
     let depId;
     if (supportRequest.department && supportRequest.department._id) {
       depId = supportRequest.department._id;
@@ -111,7 +112,7 @@ class DirectivesChatbotPlug {
       log: this.log
     });
 
-    let context =  {
+    this.context =  {
       projectId: projectId,
       token: token,
       supportRequest: supportRequest,
@@ -124,273 +125,291 @@ class DirectivesChatbotPlug {
       log: this.log
     }
     
-    let curr_directive_index = -1;
-    if (this.log) { console.log("processing directives:", JSON.stringify(directives)); }
-    function process(directive) {
-      if (directive) {
-        //console.log("directive:", directive);
-        //console.log("directive.name:", directive.name);
-      }
-      let directive_name = null;
-      if (directive && directive.name) {
-        directive_name = directive.name.toLowerCase();
-      }
-      if (directive == null) {
-        theend();
-      }
-      else if (directive_name === Directives.DEPARTMENT) {
-        // let dep_name = "default department";
-        // if (directive.parameter) {
-        //   dep_name = directive.parameter;
-        // }
-        const departmentDir = new DirDepartment(context);
-        departmentDir.execute(directive, () => {
-          console.log("departmentDir.executed", directive);
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.HMESSAGE) {
-        const messageDir = new DirMessage(
-          {
-            API_ENDPOINT: API_URL,
-            TILEBOT_ENDPOINT:TILEBOT_ENDPOINT,
-            log: false,
-            projectId: projectId,
-            requestId: requestId,
-            token: token
-          }
-        );
-        messageDir.execute(directive, async () => {
-          process(nextDirective());
-        });
-        
-        // if (directive.parameter) {
-        //   let text = directive.parameter.trim();
-        //   let message = {
-        //     sender: "system22", // bot doesn't reply to himself
-        //     text: text,
-        //     attributes: {
-        //       subtype: "info"
-        //     }
-        //   };
-        //   tdclient.sendSupportMessage(requestId, message, () => {
-        //     process(nextDirective());
-        //   });
-        // }
+    this.curr_directive_index = -1;
+    if (this.log) { console.log("processing directives...");}
+    
+    const next_dir = await this.nextDirective(directives);
+    if (this.log) { console.log("next_dir:", JSON.stringify(next_dir));}
+    await this.process(next_dir);
+  }
 
-      }
-      else if (directive_name === Directives.INTENT) {
-        // const intentDir = new DirIntent(
-        //   {
-        //     API_ENDPOINT: API_URL,
-        //     TILEBOT_ENDPOINT:TILEBOT_ENDPOINT,
-        //     log: false,
-        //     supportRequest: supportRequest,
-        //     token: token
-        //   }
-        // );
-        const intentDir = new DirIntent(context);
-        intentDir.execute(directive, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.MESSAGE) {
-        const messageDir = new DirMessage(context);
-        messageDir.execute(directive, async () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.REPLY) {
-        console.log("...DirReply");
-        new DirReply(context).execute(directive, async () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.IF_OPEN_HOURS) {
-        const ifOpenHours = new DirIfOpenHours(context);
-        ifOpenHours.execute(directive, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.IF_ONLINE_AGENTS) {
-        const ifOnlineAgents = new DirIfOnlineAgents(context);
-          // {
-          //   tdclient: tdclient,
-          //   intentDir: intentDir,
-          //   log: false
-          // });
-          ifOnlineAgents.execute(directive, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.FUNCTION_VALUE) {
-        // console.log("...DirAssignFromFunction")
-        const assign_dir = new DirAssignFromFunction(context);
-        assign_dir.execute(directive, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.CONDITION) {
-        // console.log("...DirCondition");
-        const condition_dir = new DirCondition(context);
-        condition_dir.execute(directive, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.ASSIGN) {
-        // console.log("...DirAssign", context.log);
-        const assign_dir = new DirAssign(context);
-        assign_dir.execute(directive, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.WHEN_OPEN) {
-        // DEPRECATED
-        const whenOpenDir = new DirWhenOpen(
-          {
-            tdclient: tdclient, // matches open hours
-            log: false
-          });
-        whenOpenDir.execute(directive, directives, curr_directive_index, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.WHEN_CLOSED) {
-        // DEPRECATED
-        const whenOpenDir = new DirWhenOpen(
-          {
-            tdclient: tdclient,
-            checkOpen: false, // matches closed hours
-            log: false
-          });
-        whenOpenDir.execute(directive, directives, curr_directive_index, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.IF_AGENTS) {
-        // DEPRECATED
-        const ifNoAgentsDir = new DirIfAvailableAgents(
-          {
-            tdclient: tdclient,
-            checkAgents: true, // check available agents > 0
-            log: false
-          });
-        ifNoAgentsDir.execute(directive, directives, curr_directive_index, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.IF_NO_AGENTS) {
-        // DEPRECATED
-        const ifNoAgentsDir = new DirIfAvailableAgents(
-          {
-            tdclient: tdclient,
-            checkAgents: false, // check no available agents
-            log: false
-          });
-        ifNoAgentsDir.execute(directive, directives, curr_directive_index, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.AGENT) {
-        console.log("...DirMoveToAgent");
-        const agentDir = new DirMoveToAgent(context);
-        agentDir.execute(directive, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.WHEN_ONLINE_MOVE_TO_AGENT) { // DEPRECATED?
-        if (depId) {
-          const agentDir = new DirMoveToAgent(
-            {
-              tdclient: tdclient,
-              requestId: requestId,
-              depId: depId
-            }
-          );
-          if (!directive.body) {
-            directive.action = {}
-            directive.action.body = {
-              whenOnlineOnly: true
-            }
+  async nextDirective(directives) {
+    // console.log("....nextDirective() checkStep():");
+    const go_on = await TiledeskChatbot.checkStep(
+      this.context.tdcache, this.context.requestId, TiledeskChatbot.MAX_STEPS
+    );
+    // const current_step = await TiledeskChatbot.currentStep(this.context.tdcache, this.context.requestId);
+    // console.log("........nextDirective() currentStep:", current_step);
+    if (go_on == false) {
+      // console.log("..nextDirective() Stopped!");
+      return this.errorMessage("Request error: anomaly detection. MAX ACTIONS exeeded.");
+    }
+    // else if (go_on == 2) {
+    //   return null;
+    // }
+    else { // continue with the next directive
+      // console.log("Go on!");
+    }
+    this.curr_directive_index += 1;
+    if (this.curr_directive_index < directives.length) {
+      let nextd = directives[this.curr_directive_index];
+      // console.log("nextd:", nextd);
+      return nextd;
+    }
+    else {
+      return null;
+    }
+  }
+
+  errorMessage(message) {
+    return {
+      name: "message",
+      action: {
+        "_tdThenStop": true,
+        text: message,
+        attributes: {
+          runtimeError: {
+            message: message
           }
-          agentDir.execute(directive, () => {
-            process(nextDirective());
-          });
+        }
+      }
+    }
+  }
+
+  async process(directive) {
+    // console.log("process(directive):", JSON.stringify(directive));
+    let context = this.context;
+    if (directive) {
+      // if (context.log) { console.log("process(directive):", JSON.stringify(directive));}
+    }
+    let directive_name = null;
+    if (directive && directive.name) {
+      directive_name = directive.name.toLowerCase();
+    }
+    if (directive == null || (directive !== null && directive["name"] === undefined)) {
+      if (context.log) { console.log("stop process(). directive is (null?):", directive);}
+      this.theend();
+    }
+    else if (directive_name === Directives.DEPARTMENT) {
+      new DirDepartment(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.HMESSAGE) {
+      new DirMessage(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.INTENT) {
+      // console.log(".....DirIntent")
+      new DirIntent(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.MESSAGE) {
+      new DirMessage(context).execute(directive, async (stop) => {
+        if (stop) {
+          if (context.log) { console.log("Stopping Actions on:", directive);}
+          this.theend();
         }
         else {
-          console.log("Warning. DepId null while calling 'WHEN_ONLINE_MOVE_TO_AGENT' directive")
-          process(nextDirective());
+          let next_dir = await this.nextDirective(this.directives);
+          this.process(next_dir);
         }
-      }
-      else if (directive_name === Directives.CLOSE) {
-        // console.log("Exec close()")
-        new DirClose(context).execute(directive, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.REMOVE_CURRENT_BOT) {
-        new DirRemoveCurrentBot(context).execute(directive, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.REPLACE_BOT) {
-        new DirReplaceBot(context).execute(directive, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.WAIT) {
-        new DirWait(context).execute(directive, () => {
-          process(nextDirective());
-        });
-      }
-      else if (directive_name === Directives.LOCK_INTENT) {
-        new DirLockIntent(context).execute(directive, () => {
-          process(nextDirective());
+      });
+    }
+    else if (directive_name === Directives.REPLY) {
+      console.log("...DirReply");
+      new DirReply(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.IF_OPEN_HOURS) {
+      new DirIfOpenHours(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.IF_ONLINE_AGENTS) {
+      new DirIfOnlineAgents(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.FUNCTION_VALUE) {
+      // console.log("...DirAssignFromFunction")
+      new DirAssignFromFunction(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.CONDITION) {
+      // console.log("...DirCondition");
+      new DirCondition(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.ASSIGN) {
+      // console.log("...DirAssign", context.log);
+      new DirAssign(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.WHEN_OPEN) {
+      // DEPRECATED
+      const whenOpenDir = new DirWhenOpen(
+        {
+          tdclient: tdclient, // matches open hours
+          log: false
         });
-      }
-      else if (directive_name === Directives.UNLOCK_INTENT) {
-        new DirUnlockIntent(context).execute(directive, () => {
-          process(nextDirective());
+      whenOpenDir.execute(directive, directives, curr_directive_index, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.WHEN_CLOSED) {
+      // DEPRECATED
+      const whenOpenDir = new DirWhenOpen(
+        {
+          tdclient: tdclient,
+          checkOpen: false, // matches closed hours
+          log: false
         });
-      }
-      else if (directive_name === Directives.FIRE_TILEDESK_EVENT) {
-        new DirFireTiledeskEvent(context).execute(directive, () => {
-          process(nextDirective());
+      whenOpenDir.execute(directive, directives, curr_directive_index, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.IF_AGENTS) {
+      // DEPRECATED
+      const ifNoAgentsDir = new DirIfAvailableAgents(
+        {
+          tdclient: tdclient,
+          checkAgents: true, // check available agents > 0
+          log: false
         });
-      }
-      else if (directive_name === Directives.SEND_EMAIL) {
-        // console.log("...DirSendEmail");
-        new DirSendEmail(context).execute(directive, () => {
-          process(nextDirective());
+      ifNoAgentsDir.execute(directive, directives, curr_directive_index, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.IF_NO_AGENTS) {
+      // DEPRECATED
+      const ifNoAgentsDir = new DirIfAvailableAgents(
+        {
+          tdclient: tdclient,
+          checkAgents: false, // check no available agents 
+          log: false
         });
-      }
-      else if (directive_name === Directives.DELETE) {
-        // console.log("got delete dir...")
-        new DirDeleteVariable(context).execute(directive, async () => {
-            // const requestVariables = 
-            // await TiledeskChatbot.allParametersStatic(
-            //   tdcache, requestId
-            // );
-            // console.log("delete executed.",directive, requestVariables);
-            process(nextDirective());
+      ifNoAgentsDir.execute(directive, directives, curr_directive_index, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.AGENT) {
+      console.log("...DirMoveToAgent");
+      new DirMoveToAgent(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.WHEN_ONLINE_MOVE_TO_AGENT) { // DEPRECATED?
+      // let depId;
+      // if (context.supportRequest && context.supportRequest.department && context.supportRequest.department._id) {
+        // depId = context.supportRequest.department._id;
+        // console.log("context.supportRequest", JSON.stringify(context.supportRequest));
+        // const agentDir = new DirMoveToAgent(
+        //   {
+        //     tdclient: context.tdclient,
+        //     requestId: context.requestId,
+        //     depId: depId
+        //   }
+        // );
+        // if (!directive.action) {
+        //   directive.action = {}
+        //   directive.action = {
+        //     whenOnlineOnly: true
+        //   }
+        // }
+        new DirMoveToAgent(context).execute(directive, async () => {
+          let next_dir = await this.nextDirective(this.directives);
+          this.process(next_dir);
         });
-      }
-      else {
-        //console.log("Unhandled Post-message Directive:", directive_name);
-        process(nextDirective());
-      }
+      // }
+      // else {
+      //   console.log("Warning. DepId null while calling 'WHEN_ONLINE_MOVE_TO_AGENT' directive")
+      //   let next_dir = await this.nextDirective(this.directives);
+      //   this.process(next_dir);
+      // }
     }
-    process(nextDirective());
-
-    function nextDirective() {
-      curr_directive_index += 1;
-      if (curr_directive_index < directives.length) {
-        let nextd = directives[curr_directive_index];
-        return nextd;
-      }
-      else {
-        return null;
-      }
+    else if (directive_name === Directives.CLOSE) {
+      // console.log("Exec close()")
+      new DirClose(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.REMOVE_CURRENT_BOT) {
+      new DirRemoveCurrentBot(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.REPLACE_BOT) {
+      new DirReplaceBot(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.WAIT) {
+      console.log("........ DirWait");
+      new DirWait(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.LOCK_INTENT) {
+      new DirLockIntent(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.UNLOCK_INTENT) {
+      new DirUnlockIntent(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.FIRE_TILEDESK_EVENT) {
+      new DirFireTiledeskEvent(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.SEND_EMAIL) {
+      // console.log("...DirSendEmail");
+      new DirSendEmail(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else if (directive_name === Directives.DELETE) {
+      // console.log("got delete dir...")
+      new DirDeleteVariable(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
+    else {
+      //console.log("Unhandled Post-message Directive:", directive_name);
+      let next_dir = await this.nextDirective(this.directives);
+      this.process(next_dir);
     }
   }
 

package/tiledeskChatbotPlugs/Filler.js

@@ -1,6 +1,10 @@
 class Filler {
 
   fill(text, parameters) {
+    if (text == null || text == undefined) {
+      console.log("Skip filling. 'text' is null");
+      return text;
+    }
     if (parameters) {
       for (const [key, value] of Object.entries(parameters)) {
         text = text.replace(new RegExp("(\\$\\{" + key + "\\})", 'i'), value); //parameters[key]);

package/tiledeskChatbotPlugs/directives/DirAssign.js

@@ -35,10 +35,8 @@ class DirAssign {
       params = this.parseParams(directive.parameter);
       // console.log("DirAssign params:", params);
       action = {
-        // body: {
-          expression: params.expression,
-          assignTo: params.assignTo
-        // }
+        expression: params.expression,
+        assignTo: params.assignTo
       }
       // console.log("DirAssign action:", action);
     }
@@ -80,7 +78,15 @@ class DirAssign {
       const value = await new TiledeskExpression().evaluateExpression(expression, variables);
       if (this.log) {console.log("(DirAssign) executed expression:", expression, "value:", value);}
       await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, variableName, value);
-      if (this.log) {console.log("(DirAssign) Assigned:", value, "to", variableName);}
+      if (this.log) {
+        console.log("(DirAssign) Assigned:", variableName, "=", value);
+        const all_parameters = await TiledeskChatbot.allParametersStatic(this.context.tdcache, this.context.requestId);
+        for (const [key, value] of Object.entries(all_parameters)) {
+          const value_type = typeof value;
+          if (this.log) {console.log("(DirAssign) request parameter:", key, "value:", value, "type:", value_type)}
+        }
+      }
+
       callback();
     }
     else {

package/tiledeskChatbotPlugs/directives/DirCondition.js

@@ -53,11 +53,9 @@ class DirCondition {
         return;
       }
       action = {
-        // body: {
-          condition: params.condition,
-          trueIntent: params.trueIntent,
-          falseIntent: params.falseIntent
-        // }
+        condition: params.condition,
+        trueIntent: params.trueIntent,
+        falseIntent: params.falseIntent
       }
     }
     else {
@@ -75,14 +73,25 @@ class DirCondition {
     // const trueIntent = action.body.trueIntent;
     // const falseIntent = action.body.falseIntent;
     const condition = action.condition;
-    const trueIntent = action.trueIntent;
-    const falseIntent = action.falseIntent;
+    let trueIntent = action.trueIntent;
+    let falseIntent = action.falseIntent;
+    if (trueIntent && trueIntent.trim() === "") {
+      trueIntent = null;
+    }
+    if (falseIntent && falseIntent.trim() === "") {
+      falseIntent = null;
+    }
     if (this.log) {console.log("condition action:", action);}
     if (!trueIntent && !falseIntent) {
       if (this.log) {console.log("Invalid condition, no intents specified");}
       callback();
       return;
     }
+    if (condition === null || (condition !== null && condition.trim === "")) {
+      if (this.log) {console.log("Invalid condition, empty or null:", condition);}
+      callback();
+      return;
+    }
     let trueIntentDirective = null;
     if (trueIntent) {
       trueIntentDirective = DirIntent.intentDirectiveFor(trueIntent);

package/tiledeskChatbotPlugs/directives/DirDeleteVariable.js

@@ -21,9 +21,7 @@ class DirDeleteVariable {
     }
     else if (directive.parameter) {
       action = {
-        // body: {
-          variableName: directive.parameter
-        // }
+        variableName: directive.parameter
       }
     }
     this.go(action, () => {

package/tiledeskChatbotPlugs/directives/DirDepartment.js

@@ -23,9 +23,7 @@ class DirDepartment {
         dep_name = directive.parameter.trim();
       }
       action = {
-        // body: {
-          depName: dep_name
-        // }
+        depName: dep_name
       }
     }
     this.go(action, () => {

package/tiledeskChatbotPlugs/directives/DirIfOnlineAgents.js

@@ -53,10 +53,8 @@ class DirIfOnlineAgents {
       //   return;
       // }
       action = {
-        // body: {
-          trueIntent: params.trueIntent,
-          falseIntent: params.falseIntent
-        // }
+        trueIntent: params.trueIntent,
+        falseIntent: params.falseIntent
       }
     }
     else {

package/tiledeskChatbotPlugs/directives/DirIntent.js

@@ -49,9 +49,7 @@ class DirIntent {
     }
     else if (directive.parameter && directive.parameter.trim() !== "") {
       action = {
-        // body: {
-          intentName: directive.parameter.trim()
-        // }
+        intentName: directive.parameter.trim()
       }
     }
     else {

package/tiledeskChatbotPlugs/directives/DirMessage.js

@@ -75,8 +75,13 @@ class DirMessage {
       callback();
       return;
     }
-    this.go(action, () => {
-      callback();
+    this.go(action, async () => {
+      if (action["_tdThenStop"] == true) {
+        callback(true); // stopping the action flow
+      }
+      else {
+        callback();
+      }
     });
   }
 

package/tiledeskChatbotPlugs/directives/DirMoveToAgent.js

@@ -1,4 +1,5 @@
 const { TiledeskClient } = require('@tiledesk/tiledesk-client');
+const { Directives } = require('./Directives');
 
 class DirMoveToAgent {
 
@@ -33,18 +34,16 @@ class DirMoveToAgent {
   }
 
   execute(directive, callback) {
-    let action;
-    if (directive.action) {
-      action = directive.action;
-      this.go(action, () => {
-        callback();
-      });
+    directive.action = {};
+    if (directive.name === Directives.WHEN_ONLINE_MOVE_TO_AGENT) { // TEMP
+      directive.action = {
+        whenOnlineOnly: true
+      }
     }
-    else {
+    this.go(directive.action, () => {
       callback();
-    }
+    });
   }
-
   go(action, callback) {
     if (action.whenOnlineOnly === true) {
       this.tdclient.openNow((err, result) => {

package/tiledeskChatbotPlugs/directives/DirReplaceBot.js

@@ -22,9 +22,7 @@ class DirReplaceBot {
     else if (directive.parameter) {
       let botName = directive.parameter.trim();
       action = {
-        // body: {
-          botName: botName
-        // }
+        botName: botName
       }
     }
     else {

package/tiledeskChatbotPlugs/directives/DirReply.js

@@ -12,10 +12,11 @@ class DirReply {
     this.requestId = context.requestId;
     this.token = context.token;
     this.tdcache = context.tdcache;
+    this.log = context.log;
   }
 
   execute(directive, callback) {
-    console.log("Reply directive:", directive);
+    console.log("Reply directive:", JSON.stringify(directive));
     let action;
     if (directive.action) {
       action = directive.action;
@@ -44,16 +45,26 @@ class DirReply {
       await TiledeskChatbot.allParametersStatic(
         this.tdcache, this.requestId
       );
+      if (this.log) {
+        for (const [key, value] of Object.entries(requestVariables)) {
+          const value_type = typeof value;
+          if (this.log) {console.log("(DirReply) request parameter:", key, "value:", value, "type:", value_type)}
+        }
+      }
       const filler = new Filler();
       // fill text attribute
       message.text = filler.fill(message.text, requestVariables);
-      // fill commands' text attribute
+      if (this.log) {console.log("filling commands'. Message:", JSON.stringify(message));}
       if (message.attributes && message.attributes.commands) {
+        if (this.log) {console.log("filling commands'. commands found.");}
         let commands = message.attributes.commands;
-        if (commands.length > 1) {
+        if (this.log) {console.log("commands:", JSON.stringify(commands), commands.length);}
+        if (commands.length > 0) {
+          if (this.log) {console.log("commands' found");}
           for (let i = 0; i < commands.length; i++) {
             if (commands[i].type === 'message' && commands[i].message && commands[i].message.text) {
-              commands[i].message.text = this.fillWithRequestParams(commands[i].message.text, requestVariables);
+              commands[i].message.text = filler.fill(commands[i].message.text, requestVariables);
+              if (this.log) {console.log("command filled:", commands[i].message.text);}
             }
           }
         }

package/tiledeskChatbotPlugs/directives/DirSendEmail.js

@@ -3,7 +3,7 @@ const { param } = require('express/lib/request');
 const ms = require('minimist-string');
 const { TiledeskChatbot } = require('../../models/TiledeskChatbot');
 const { Filler } = require('../Filler');
-const { TiledeskClient } = require('@tiledesk/tiledesk-client');
+// const { TiledeskClient } = require('@tiledesk/tiledesk-client');
 
 class DirSendEmail {
 
@@ -46,11 +46,9 @@ class DirSendEmail {
     else if (directive.parameter && directive.parameter.trim() !== "") {
       const params = this.parseParams(directive.parameter);
       action = {
-        // body: {
-          subject: params.subject,
-          text: params.text,
-          to: params.to
-        // }
+        subject: params.subject,
+        text: params.text,
+        to: params.to
       }
     }
     else {

package/tiledeskChatbotPlugs/directives/DirWait.js

@@ -31,13 +31,17 @@ class DirWait {
         millis: 500
       }
     }
+    console.log("____-----_", action)
     this.go(action, () => {
+      console.log("YES", callback)
       callback();
     })
   }
 
   go(action, callback) {
+    console.log(">>>>__", callback)
     setTimeout(() => {
+      console.log("QUINO....__")
       callback();
     }, action.millis);
   }

package/tiledeskChatbotPlugs/directives/Directives.js

@@ -23,11 +23,11 @@ class Directives {
   static LOCK_INTENT = "lockintent";
   static UNLOCK_INTENT = "unlockintent";
   static FIRE_TILEDESK_EVENT = "firetiledeskevent";
-  static SEND_EMAIL = "sendemail";
+  static SEND_EMAIL = "email";
   static DELETE = "delete";
   static IF_OPEN_HOURS = "ifopenhours";
   static IF_ONLINE_AGENTS = "ifonlineagents";
-  static IF_NOT_OPEN_HOURS = "ifnotopenhours";
+  static IF_NOT_OPEN_HOURS = "ifnotopenhours"; // DEPRECATED
   static FUNCTION_VALUE = "functionvalue";
   static CONDITION = "condition";
   static ASSIGN = "assign";
@@ -36,13 +36,13 @@ class Directives {
   static REPLY = 'reply';
 
   static actionToDirective(action) {
-    console.log("actionToDirective:", action);
+    // console.log("actionToDirective:", action);
     let directive = {
-      name: action["_tdActionType"],//.type, //_tdActionType
+      name: action["_tdActionType"],
       action: action
     }
     // delete directive.action["_tdActionType"];
-    console.log("Directive out:", directive);
+    // console.log("Directive out:", directive);
     return directive;
   }
 }