@cognigy/rest-api-client 0.9.1 → 0.12.0

package/build/shared/charts/descriptors/message/question/question.js

@@ -1,12 +1,55 @@
 "use strict";
+/**
+ * 	This Question Node asks the user a question and expects a certain type of answer back.
+ *	The answer is evaluated by the Node and if it's invalid, the user is guided towards
+ *	giving a correct answer.
+ *
+ *	The Node executes the following steps, all of which have been marked as #regions in the code below
+ *
+ *  0. Check if we're currently in a reconfirmation of a valid answer and if yes, handle it
+ *
+ *	1. Check if answer exists in context and stop if it does
+ *
+ *	2. Check if this is the first time the node is hit and if yes, ask the question and stop (return); if not
+ *
+ *	3. - doesnt exist anymore -
+ *
+ *	4. Run actual evaluation of the answer using evaluateQuestionAnswer
+ *	  4.1 If result location was specified, try to get the result from there
+ *
+ *	5. If answer is:
+ *	  5.1 VALID
+ *		5.1.1 If reconfirmation is needed, start reconfirmation process and stop
+ *	    5.1.2 Store the answer either in Context or Input
+ *	    5.1.3 Store the answer also in the profile
+ *	    5.1.4 Reset markers and activeQuestion in system Context and return
+ *
+ *	  5.2 INVALID
+ *	    5.2.1 Check if we should escalate on intent and if yes, do so
+ *	    5.2.2 Otherwise (!) check if we should escalate on multiple wrong answers and if yes, do so
+ *	    5.2.3 Check if we should say the reprompt an if yes, say it, plus the question again
+ *	    5.2.4 Sets itself as the next Node and stops execution
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUESTION = void 0;
+//#region Imports
 /* Custom modules */
 const createNodeDescriptor_1 = require("../../../createNodeDescriptor");
 const evaluateQuestionAnswer_1 = require("./utils/evaluateQuestionAnswer");
 const say_1 = require("../say");
+const goTo_1 = require("../../logic/goTo");
+const executeFlow_1 = require("../../logic/executeFlow");
 const BaseContext_1 = require("../../../../helper/BaseContext");
+const getQuestionText_1 = require("./utils/getQuestionText");
+const storeQuestionAnswer_1 = require("./utils/storeQuestionAnswer");
+const generateAnswerShortForm_1 = require("./utils/generateAnswerShortForm");
+const validateQuestionAnswer_1 = require("./utils/validateQuestionAnswer");
+const service_1 = require("../../service");
 const datepickerUtils_1 = require("./utils/datepickerUtils");
+const resetNodeState_1 = require("./utils/resetNodeState");
+//#endregion Interfaces
 exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
+    //#region DescriptorFields
     type: "question",
     defaultLabel: "Question",
     summary: "Ask a question and waits for a valid answer",
@@ -17,7 +60,6 @@ exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
     appearance: {
         showIcon: false
     },
-    // @ts-ignore
     fields: [
         {
             key: "type",
@@ -70,6 +112,10 @@ exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
                         label: "Money",
                         value: "money"
                     },
+                    {
+                        label: "URL",
+                        value: "url"
+                    },
                     {
                         label: "Percentage",
                         value: "percentage"
@@ -78,6 +124,14 @@ exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
                         label: "Regex",
                         value: "regex",
                     },
+                    {
+                        label: "Data",
+                        value: "data",
+                    },
+                    {
+                        label: "Custom",
+                        value: "custom",
+                    },
                 ],
             },
             defaultValue: 'yesNo'
@@ -100,7 +154,17 @@ exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
             type: "cognigyText",
             label: "Reprompt Message",
             description: "Message to output if the given answer is invalid",
-            defaultValue: "Not sure I understood this correctly."
+            defaultValue: "Not sure I understood this correctly.",
+            params: {
+                multiline: true
+            }
+        },
+        {
+            key: "repromptCondition",
+            type: "cognigyText",
+            label: "Reprompt Condition",
+            description: "Condition to check before outputting Reprompt Message",
+            defaultValue: ""
         },
         {
             key: "validationRepeat",
@@ -109,6 +173,13 @@ exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
             description: "Repeat question if given answer is invalid",
             defaultValue: true
         },
+        {
+            key: "skipRepromptOnIntent",
+            type: "toggle",
+            label: "Skip on Intent",
+            description: "Skips the reprompt if an intent was found",
+            defaultValue: false
+        },
         {
             key: "keyphraseTag",
             type: "cognigyText",
@@ -131,6 +202,7 @@ exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
             key: "regex",
             type: "cognigyText",
             label: "Regular Expression",
+            description: "Provide a regular expression (e.g. /\\d{5}/)",
             condition: {
                 key: "type",
                 value: "regex"
@@ -139,11 +211,11 @@ exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
         {
             key: "storeInContactProfile",
             type: "toggle",
-            label: "Write Result to Contact Profile"
+            label: "Store Result in Contact Profile"
         },
         {
             key: "profileKey",
-            type: "cognigyText",
+            type: "profileSchemaField",
             label: "Profile Key to use",
             condition: {
                 key: "storeInContactProfile",
@@ -179,35 +251,586 @@ exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
                 value: true
             }
         },
+        {
+            key: "onlyAcceptEscalationIntents",
+            type: "toggle",
+            label: "Only Accept Escalation Intents",
+            description: "Ignore all Intents on Answer, except Escalation Intents",
+            condition: {
+                key: "type",
+                value: "intent",
+                negate: true
+            }
+        },
         {
             key: "parseResultOnEntry",
             type: "toggle",
             label: "Skip if Answer in Input",
             description: "Skips the question if it was already answered when the Node is hit"
-        }
-    ] // @ts-ignore
-        .concat(datepickerUtils_1.getDatePickerFields({
-        "key": "type",
-        "value": "date"
-    })),
-    sections: [
+        },
         {
-            key: "profile",
-            label: "Profile Storage",
-            defaultCollapsed: true,
-            fields: [
-                "storeInContactProfile",
-                "profileKey"
-            ]
+            key: "datepickerExplanation",
+            type: "description",
+            label: " ",
+            params: {
+                text: "Date questions can prompt the user with an interactive datepicker which is configured in the sections below"
+            },
+            condition: {
+                key: "type",
+                value: "date"
+            }
+        },
+        {
+            key: "additionalValidation",
+            type: "cognigyText",
+            label: "Additional Validation",
+            description: "User Input must pass this validation in addition to the inbuilt field-validation (e.g. Email) to be considered valid",
+            defaultValue: ""
+        },
+        {
+            key: "resultLocation",
+            type: "cognigyText",
+            label: "Result Location",
+            description: "The location to retrieve the result from (e.g. input.text)",
+            defaultValue: ""
+        },
+        {
+            key: "maxExecutionDiff",
+            type: "number",
+            label: "Forget Question Threshold",
+            description: "The max number of inputs between hitting the Node the first time and now where we still validate the answer. Otherwise we ask the question again.",
+            defaultValue: 1
+        },
+        {
+            key: "escalateAnswersAction",
+            type: "select",
+            label: "Escalation Action",
+            description: "What should happen after the threshold of wrong answers is reached?",
+            params: {
+                options: [
+                    {
+                        label: "No Escalation",
+                        value: "none"
+                    },
+                    {
+                        label: "Output Message",
+                        value: "text",
+                    },
+                    {
+                        label: "Skip Question",
+                        value: "skip",
+                    },
+                    {
+                        label: "Go to Node",
+                        value: "goto"
+                    },
+                    {
+                        label: "Execute Flow and return",
+                        value: "execute"
+                    },
+                    {
+                        label: "Handover to Human Agent",
+                        value: "handover"
+                    }
+                ],
+            },
+            defaultValue: 'none'
+        },
+        {
+            key: "escalateAnswersThreshold",
+            type: "slider",
+            label: "Wrong Answer Count Trigger",
+            description: "Number of incorrect answers on which escalation will be triggered.",
+            params: {
+                min: 1,
+                max: 10,
+                step: 1,
+            },
+            defaultValue: 3,
+            condition: {
+                key: "escalateAnswersAction",
+                value: "none",
+                negate: true
+            }
+        },
+        {
+            key: "escalateAnswersGotoTarget",
+            type: "flowNode",
+            label: "GoTo Target",
+            condition: {
+                key: "escalateAnswersAction",
+                value: "goto"
+            }
+        },
+        {
+            key: "escalateAnswersExecuteTarget",
+            type: "flowNode",
+            label: "Execute Target",
+            condition: {
+                key: "escalateAnswersAction",
+                value: "execute"
+            }
+        },
+        {
+            key: "escalateAnswersGotoExecutionMode",
+            type: "select",
+            description: "Go to new Node and continue execution or wait for input",
+            label: "GoTo Execution Mode",
+            defaultValue: "continue",
+            params: {
+                options: [
+                    {
+                        label: "Go to Node and continue",
+                        value: "continue"
+                    },
+                    {
+                        label: "Go to Node and wait for Input",
+                        value: "wait"
+                    },
+                ]
+            },
+            condition: {
+                key: "escalateAnswersAction",
+                value: "goto"
+            }
+        },
+        {
+            key: "escalateAnswersInjectedText",
+            label: "Optional Injected Text",
+            type: "cognigyText",
+            description: "Text to use when continuing the execution. If no text is provided, input.text is used.",
+            defaultValue: "",
+            condition: {
+                key: "escalateAnswersAction",
+                value: "goto"
+            }
+        },
+        {
+            key: "escalateAnswersInjectedData",
+            label: "Optional Injected Data",
+            type: "json",
+            description: "Data to use when continuing the execution. If no data is provided, input.data is used.",
+            defaultValue: "{}",
+            condition: {
+                key: "escalateAnswersAction",
+                value: "goto"
+            }
+        },
+        {
+            key: "escalateAnswersMessage",
+            type: "say",
+            label: "Escalation Message",
+            defaultValue: {
+                data: "{}",
+                type: "text",
+                linear: false,
+                loop: false,
+                text: [""],
+                _cognigy: {},
+            },
+            condition: {
+                key: "escalateAnswersAction",
+                value: "text"
+            }
+        },
+        {
+            key: "escalateAnswersRepromptPrevention",
+            type: "toggle",
+            label: "Prevent Reprompt on Escalation",
+            defaultValue: true,
+            condition: {
+                key: "escalateAnswersAction",
+                value: "text"
+            }
+        },
+        {
+            key: "escalateAnswersHandoverText",
+            type: "cognigyText",
+            label: "Handover Accepted Message",
+            description: "The message to display to the user once the handover request was accepted by the live chat provider",
+            condition: {
+                key: "escalateAnswersAction",
+                value: "handover"
+            }
+        },
+        {
+            key: "escalateAnswersRepeatHandoverMessage",
+            type: "toggle",
+            label: "Repeat Handover Accepted Message",
+            description: "Repeatedly respond with Handover Accepted Message for each user input until human agent responds",
+            defaultValue: false,
+            condition: {
+                key: "escalateAnswersAction",
+                value: "handover"
+            }
+        },
+        {
+            key: "escalateAnswersHandoverCancelIntent",
+            type: "cognigyText",
+            label: "Cancel Intent",
+            description: "Name of the intent which will cancel the handover",
+            condition: {
+                key: "escalateAnswersAction",
+                value: "handover"
+            }
+        },
+        {
+            key: "escalateAnswersHandoverQuickReply",
+            type: "cognigyText",
+            label: "Cancel Button Text",
+            description: "Text of the Quick Reply Button which sends the user back to the Virtual Agent",
+            condition: {
+                key: "escalateAnswersAction",
+                value: "handover"
+            }
+        },
+        process.env.FEATURE_USE_COGNIGY_LIVE_AGENT && {
+            key: "escalateAnswersHandoverLiveAgentInboxId",
+            type: "cognigyText",
+            label: "Live Agent Inbox Id",
+            description: "Inbox Id in Live Agent",
+            condition: {
+                key: "escalateAnswersAction",
+                value: "handover"
+            }
+        },
+        {
+            key: "escalateAnswersHandoverChatwootInboxId",
+            type: "cognigyText",
+            label: "Chatwoot Inbox Id",
+            description: "Inbox Id in Chatwoot",
+            condition: {
+                key: "escalateAnswersAction",
+                value: "handover"
+            }
+        },
+        {
+            key: "escalateAnswersHandoverSalesforcePrechatEntities",
+            type: "json",
+            label: "Salesforce Prechat Entities",
+            description: "The Salesforce entity that should be used.",
+            defaultValue: "[]",
+            condition: {
+                key: "escalateAnswersAction",
+                value: "handover"
+            }
+        },
+        {
+            key: "escalateAnswersHandoverSalesforcePrechatDetails",
+            type: "json",
+            label: "Salesforce Prechat Details",
+            description: "The details that should be displayed to the Live Chat Agent.",
+            defaultValue: "[]",
+            condition: {
+                key: "escalateAnswersAction",
+                value: "handover"
+            }
+        },
+        {
+            key: "escalateAnswersOnce",
+            type: "toggle",
+            label: "Only escalate once",
+            description: "Only escalate exactly at the threshold but not after",
+            defaultValue: true,
+            condition: {
+                key: "escalateAnswersAction",
+                value: "none",
+                negate: true
+            }
+        },
+        {
+            key: "escalateIntentsAction",
+            type: "select",
+            label: "Escalation Action",
+            description: "What shall happen after an intent was found?",
+            params: {
+                options: [
+                    {
+                        label: "No Escalation",
+                        value: "none"
+                    },
+                    {
+                        label: "Output Message",
+                        value: "text",
+                    },
+                    {
+                        label: "Skip Question",
+                        value: "skip",
+                    },
+                    {
+                        label: "Go to Node",
+                        value: "goto"
+                    },
+                    {
+                        label: "Execute Flow and return",
+                        value: "execute"
+                    },
+                    {
+                        label: "Handover to Human Agent",
+                        value: "handover"
+                    }
+                ],
+            },
+            defaultValue: 'none'
+        },
+        {
+            key: "escalateIntentsValidIntents",
+            type: "chipInput",
+            label: "Valid Intents",
+            description: "List of intents which trigger escalation. Hit Enter to add each intent.",
+            condition: {
+                key: "escalateIntentsAction",
+                value: "none",
+                negate: true
+            }
+        },
+        {
+            key: "escalateIntentsThreshold",
+            type: "slider",
+            label: "Intent Score Threshold",
+            description: "The minimum score the hit intent must have to trigger an escalation.",
+            params: {
+                min: 0,
+                max: 1,
+                step: .1,
+            },
+            defaultValue: .8,
+            condition: {
+                key: "escalateIntentsAction",
+                value: "none",
+                negate: true
+            }
+        },
+        {
+            key: "escalateIntentsGotoTarget",
+            type: "flowNode",
+            label: "GoTo Target",
+            condition: {
+                key: "escalateIntentsAction",
+                value: "goto"
+            }
         },
+        {
+            key: "escalateIntentsExecuteTarget",
+            type: "flowNode",
+            label: "Execute Target",
+            condition: {
+                key: "escalateIntentsAction",
+                value: "execute"
+            }
+        },
+        {
+            key: "escalateIntentsGotoExecutionMode",
+            type: "select",
+            description: "Go to new Node and continue execution or wait for input",
+            label: "GoTo Execution Mode",
+            defaultValue: "continue",
+            params: {
+                options: [
+                    {
+                        label: "Go to Node and continue",
+                        value: "continue"
+                    },
+                    {
+                        label: "Go to Node and wait for Input",
+                        value: "wait"
+                    },
+                ]
+            },
+            condition: {
+                key: "escalateIntentsAction",
+                value: "goto"
+            }
+        },
+        {
+            key: "escalateIntentsInjectedText",
+            label: "Optional Injected Text",
+            type: "cognigyText",
+            description: "Text to use when continuing the execution. If no text provided, input.text is used.",
+            defaultValue: "",
+            condition: {
+                key: "escalateIntentsAction",
+                value: "goto"
+            }
+        },
+        {
+            key: "escalateIntentsInjectedData",
+            label: "Optional Injected Data",
+            type: "json",
+            description: "Data to use when continuing the execution. If no data provided, input.data is used.",
+            defaultValue: "{}",
+            condition: {
+                key: "escalateIntentsAction",
+                value: "goto"
+            }
+        },
+        {
+            key: "escalateIntentsMessage",
+            type: "say",
+            label: "Escalation Message",
+            defaultValue: {
+                data: "{}",
+                type: "text",
+                linear: false,
+                loop: false,
+                text: [""],
+                _cognigy: {},
+            },
+            condition: {
+                key: "escalateIntentsAction",
+                value: "text"
+            }
+        },
+        {
+            key: "escalateIntentsHandoverText",
+            type: "cognigyText",
+            label: "Handover Accepted Message",
+            description: "The message to display to the user once the handover request was accepted by the live chat provider",
+            condition: {
+                key: "escalateIntentsAction",
+                value: "handover"
+            }
+        },
+        {
+            key: "escalateIntentsRepeatHandoverMessage",
+            type: "toggle",
+            label: "Repeat Handover Accepted Message",
+            description: "Repeatedly respond with Handover Accepted Message for each user input until human agent responds",
+            defaultValue: false,
+            condition: {
+                key: "escalateIntentsAction",
+                value: "handover"
+            }
+        },
+        {
+            key: "escalateIntentsHandoverCancelIntent",
+            type: "cognigyText",
+            label: "Cancel Intent",
+            description: "Name of the intent which will cancel the handover",
+            condition: {
+                key: "escalateIntentsAction",
+                value: "handover"
+            }
+        },
+        {
+            key: "escalateIntentsHandoverQuickReply",
+            type: "cognigyText",
+            label: "Cancel Button Text",
+            description: "Text of the Quick Reply Button which sends the user back to the Virtual Agent",
+            condition: {
+                key: "escalateIntentsAction",
+                value: "handover"
+            }
+        },
+        process.env.FEATURE_USE_COGNIGY_LIVE_AGENT && {
+            key: "escalateIntentsHandoverLiveAgentInboxId",
+            type: "cognigyText",
+            label: "Live Agent Inbox Id",
+            description: "Inbox Id in Live Agent",
+            condition: {
+                key: "escalateIntentsAction",
+                value: "handover"
+            }
+        },
+        {
+            key: "escalateIntentsHandoverChatwootInboxId",
+            type: "cognigyText",
+            label: "Chatwoot Inbox Id",
+            description: "Inbox Id in Chatwoot",
+            condition: {
+                key: "escalateIntentsAction",
+                value: "handover"
+            }
+        },
+        {
+            key: "escalateIntentsHandoverSalesforcePrechatEntities",
+            type: "json",
+            label: "Salesforce Prechat Entities",
+            description: "The Salesforce entity that should be used.",
+            defaultValue: "[]",
+            condition: {
+                key: "escalateIntentsAction",
+                value: "handover"
+            }
+        },
+        {
+            key: "escalateIntentsHandoverSalesforcePrechatDetails",
+            type: "json",
+            label: "Salesforce Prechat Details",
+            description: "The details that should be displayed to the Live Chat Agent.",
+            defaultValue: "[]",
+            condition: {
+                key: "escalateIntentsAction",
+                value: "handover"
+            }
+        },
+        {
+            key: "escalateIntentsRepromptPrevention",
+            type: "toggle",
+            label: "Prevent Reprompt Message Once",
+            defaultValue: true,
+            condition: {
+                key: "escalateIntentsAction",
+                value: "text"
+            }
+        },
+        {
+            key: "reconfirmationBehaviour",
+            type: "select",
+            description: "How and if to reconfirm question answers",
+            label: "Reconfirmation Behaviour",
+            defaultValue: "none",
+            params: {
+                options: [
+                    {
+                        label: "Do not reconfirm answer",
+                        value: "none"
+                    },
+                    {
+                        label: "Reconfirm answer",
+                        value: "reconfirm"
+                    },
+                ]
+            }
+        },
+        {
+            key: "reconfirmationQuestion",
+            type: "cognigyText",
+            label: "Reconfirmation Question",
+            description: "The question to ask to reconfirm the answer",
+            defaultValue: "I heard you say [ANSWER]. Is that correct?",
+            condition: {
+                key: "reconfirmationBehaviour",
+                value: "reconfirm"
+            }
+        },
+        {
+            key: "reconfirmationQuestionReprompt",
+            type: "cognigyText",
+            label: "Reconfirmation Reprompt",
+            description: "What to say if the reconfirmation question wasn't answered with yes or no",
+            defaultValue: "I'm not sure I got that right.",
+            condition: {
+                key: "reconfirmationBehaviour",
+                value: "reconfirm"
+            }
+        },
+        ...datepickerUtils_1.getDatePickerFields({
+            "key": "type",
+            "value": "date"
+        })
+    ].filter(field => !!field),
+    sections: [
         {
             key: "context",
-            label: "Context",
+            label: "Result Storage",
             defaultCollapsed: true,
             fields: [
                 "storeResultInContext",
                 "contextKey",
-                "skipIfResultInContext"
+                "skipIfResultInContext",
+                "storeInContactProfile",
+                "profileKey"
             ]
         },
         {
@@ -217,8 +840,70 @@ exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
             fields: [
                 "validationMessage",
                 "validationRepeat",
+                "repromptCondition",
+                "skipRepromptOnIntent"
+            ]
+        },
+        {
+            key: "reconfirmation",
+            label: "Reconfirmation Options",
+            defaultCollapsed: true,
+            fields: [
+                "reconfirmationBehaviour",
+                "reconfirmationQuestion",
+                "reconfirmationQuestionReprompt"
             ]
         },
+        {
+            key: "escalateIntents",
+            label: "Escalation - Intents",
+            defaultCollapsed: true,
+            fields: [
+                "escalateIntentsAction",
+                "escalateIntentsValidIntents",
+                "escalateIntentsThreshold",
+                "escalateIntentsGotoTarget",
+                "escalateIntentsExecuteTarget",
+                "escalateIntentsGotoExecutionMode",
+                "escalateIntentsInjectedText",
+                "escalateIntentsInjectedData",
+                "escalateIntentsMessage",
+                "escalateIntentsHandoverText",
+                "escalateIntentsRepeatHandoverMessage",
+                "escalateIntentsHandoverCancelIntent",
+                "escalateIntentsHandoverQuickReply",
+                process.env.FEATURE_USE_COGNIGY_LIVE_AGENT && "escalateIntentsHandoverLiveAgentInboxId",
+                "escalateIntentsHandoverChatwootInboxId",
+                "escalateIntentsHandoverSalesforcePrechatEntities",
+                "escalateIntentsHandoverSalesforcePrechatDetails",
+                "escalateIntentsRepromptPrevention"
+            ].filter(field => !!field)
+        },
+        {
+            key: "escalateAnswers",
+            label: "Escalation - Wrong Answers",
+            defaultCollapsed: true,
+            fields: [
+                "escalateAnswersAction",
+                "escalateAnswersThreshold",
+                "escalateAnswersGotoTarget",
+                "escalateAnswersExecuteTarget",
+                "escalateAnswersGotoExecutionMode",
+                "escalateAnswersInjectedText",
+                "escalateAnswersInjectedData",
+                "escalateAnswersMessage",
+                "escalateAnswersHandoverText",
+                "escalateAnswersRepeatHandoverMessage",
+                "escalateAnswersHandoverCancelIntent",
+                "escalateAnswersHandoverQuickReply",
+                process.env.FEATURE_USE_COGNIGY_LIVE_AGENT && "escalateAnswersHandoverLiveAgentInboxId",
+                "escalateAnswersHandoverChatwootInboxId",
+                "escalateAnswersHandoverSalesforcePrechatEntities",
+                "escalateAnswersHandoverSalesforcePrechatDetails",
+                "escalateAnswersRepromptPrevention",
+                "escalateAnswersOnce",
+            ].filter(field => !!field)
+        },
         {
             key: "advanced",
             label: "Advanced",
@@ -226,22 +911,30 @@ exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
             fields: [
                 "storeDetailedResults",
                 "parseResultOnEntry",
+                "onlyAcceptEscalationIntents",
+                "additionalValidation",
+                "resultLocation",
+                "maxExecutionDiff",
             ]
         },
-    ].concat(datepickerUtils_1.getDatePickerSections("Datepicker - ", {
-        "key": "type",
-        "value": "date"
-    })),
+        ...datepickerUtils_1.getDatePickerSections("Datepicker - ", {
+            "key": "type",
+            "value": "date"
+        })
+    ],
     form: [
         { type: "field", key: "type" },
         { type: "field", key: "keyphraseTag" },
         { type: "field", key: "usePositiveOnly" },
         { type: "field", key: "regex" },
         { type: "field", key: "say" },
+        { type: "section", key: "context" },
         { type: "section", key: "reprompt" },
+        { type: "section", key: "reconfirmation" },
+        { type: "section", key: "escalateIntents" },
+        { type: "section", key: "escalateAnswers" },
         { type: "section", key: "advanced" },
-        { type: "section", key: "context" },
-        { type: "section", key: "profile" },
+        { type: "field", key: "datepickerExplanation" },
         { type: "section", key: "datepicker_config" },
         { type: "section", key: "datepicker_texts" },
         { type: "section", key: "datepicker_datesettings" },
@@ -250,15 +943,112 @@ exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
         { type: "section", key: "datepicker_advanced" }
     ],
     preview: {
-        key: "say.text.0",
-        type: "text",
+        key: "say",
+        type: "sayNode",
     },
     tags: ["basic", "message", "nlu"],
-    function: async ({ cognigy, nodeId, config }) => {
-        const { say, validationMessage, validationRepeat, storeResultInContext, contextKey, storeInContactProfile, profileKey, storeDetailedResults, parseResultOnEntry, type, datepicker_hidePicker } = config;
+    //#endregion DescriptorFields
+    function: async ({ cognigy, nodeId, config, inputOptions }) => {
+        const { say, type, validationMessage, validationRepeat, storeResultInContext, contextKey, storeInContactProfile, profileKey, storeDetailedResults, parseResultOnEntry, repromptCondition, maxExecutionDiff, resultLocation, skipRepromptOnIntent, onlyAcceptEscalationIntents, escalateAnswersAction, escalateAnswersThreshold, escalateAnswersGotoTarget, escalateAnswersExecuteTarget, escalateAnswersGotoExecutionMode, escalateAnswersInjectedText, escalateAnswersInjectedData, escalateAnswersMessage, escalateAnswersRepromptPrevention, escalateAnswersOnce, escalateAnswersHandoverText, escalateAnswersRepeatHandoverMessage, escalateAnswersHandoverCancelIntent, escalateAnswersHandoverQuickReply, escalateAnswersHandoverChatwootInboxId, escalateAnswersHandoverLiveAgentInboxId, escalateAnswersHandoverSalesforcePrechatEntities, escalateAnswersHandoverSalesforcePrechatDetails, escalateIntentsAction, escalateIntentsValidIntents, escalateIntentsThreshold, escalateIntentsGotoTarget, escalateIntentsExecuteTarget, escalateIntentsGotoExecutionMode, escalateIntentsInjectedText, escalateIntentsInjectedData, escalateIntentsMessage, escalateIntentsHandoverText, escalateIntentsRepeatHandoverMessage, escalateIntentsHandoverCancelIntent, escalateIntentsHandoverQuickReply, escalateIntentsHandoverChatwootInboxId, escalateIntentsHandoverLiveAgentInboxId, escalateIntentsHandoverSalesforcePrechatEntities, escalateIntentsHandoverSalesforcePrechatDetails, escalateIntentsRepromptPrevention, reconfirmationBehaviour, reconfirmationQuestion, reconfirmationQuestionReprompt } = config;
         const { input, context, profile, api } = cognigy;
+        // compute how often this node was hit
         const executionAmount = api.getExecutionAmount(nodeId);
-        const isFirstExecution = executionAmount === 1;
+        // compute how long ago this node was hit
+        const lastExecutionMarker = api.getLastExecutionMarker(nodeId);
+        let executionDiff = cognigy.input.execution - lastExecutionMarker;
+        // the intent reconfirmation message should not count for the executionDiff
+        if (inputOptions === null || inputOptions === void 0 ? void 0 : inputOptions.handledIntentReconfirmation) {
+            executionDiff -= 1;
+        }
+        // if this is the very first time the Node gets executed
+        // or if we have been "away" from the Node for too long (maxExecutionDiff)
+        // we consider it a first execution and show the question
+        let isFirstExecution = executionAmount === 1 || executionDiff > (maxExecutionDiff || 1);
+        // remember the current question in systemContext to later fill Input with it
+        let activeQuestion = api.getSystemContext('activeQuestion');
+        if (!activeQuestion || activeQuestion.nodeId !== nodeId) {
+            activeQuestion = {
+                nodeId,
+                type,
+                lastExecutedAt: input.execution,
+                forgetQuestionThreshold: maxExecutionDiff,
+                repromptCount: 0,
+                escalationCount: 0,
+            };
+            if (onlyAcceptEscalationIntents && config.type !== "intent") {
+                activeQuestion.onlyAcceptEscalationIntents = onlyAcceptEscalationIntents;
+                activeQuestion.escalationIntents = escalateIntentsValidIntents;
+            }
+            api.setSystemContext('activeQuestion', activeQuestion);
+        }
+        else {
+            activeQuestion.lastExecutedAt = input.execution;
+        }
+        // #region 0 CheckIfReconfirmationInProgress
+        if (api.getSystemContext("reconfirmationQuestionInProgress")) {
+            // if this is the case, we are now a YN question
+            let res = evaluateQuestionAnswer_1.evaluateQuestionAnswer({
+                cognigy, config: {
+                    "type": "yesNo"
+                }
+            });
+            const restoredInput = api.getSystemContext("reconfirmationQuestionInput");
+            input.intent = restoredInput.intent;
+            input.intentScore = restoredInput.intentScore;
+            input.intentFlow = restoredInput.intentFlow;
+            input.nlu = restoredInput.nlu;
+            input.intentLevel = restoredInput.intentLevel;
+            if (res === true) { // the reconfirmation answer was yes-like
+                // get the tentative answer that was given and store it
+                const result = activeQuestion === null || activeQuestion === void 0 ? void 0 : activeQuestion.tentativeAnswer;
+                storeQuestionAnswer_1.storeQuestionAnswer({ context, contextKey, input, result, storeResultInContext });
+                // reset everything and continue to the next node
+                resetNodeState_1.resetNodeState(api, nodeId);
+                return;
+            }
+            else if (res !== false) { // the reconfirmation answer was invalid (e.g. no yes-like or no-like answer)
+                // output reconfirmation reprompt
+                if (reconfirmationQuestionReprompt) {
+                    say_1.SAY.function({ cognigy, childConfigs: [], nodeId, config: { say: { type: "text", text: [reconfirmationQuestionReprompt] } } });
+                }
+                // output reconfirmationQuestion
+                const tentativeAnswerShortform = (activeQuestion === null || activeQuestion === void 0 ? void 0 : activeQuestion.tentativeAnswerShortform) || "";
+                say_1.SAY.function({ cognigy, childConfigs: [], nodeId, config: { say: { type: "text", text: [reconfirmationQuestion.replace("[ANSWER]", tentativeAnswerShortform)] } } });
+                // set myself as next node and stop
+                api.setNextNode(nodeId);
+                api.stopExecution();
+                return;
+            }
+            else { // the reconfirmation answer was no-like
+                // delete all remnants of this reconfirmation
+                api.deleteSystemContext('activeQuestion');
+                api.deleteSystemContext('reconfirmationQuestionInProgress');
+                api.deleteSystemContext("reconfirmationQuestionInput");
+                // pretend the question was never asked and continue
+                isFirstExecution = true;
+                api.setExecutionAmount(nodeId, 1);
+            }
+        }
+        // #endregion 0 CheckIfReconfirmationInProgress
+        let currentNodeExecutionAmount = api.getExecutionAmount(nodeId) - 1;
+        // Only validate if the forget question threshold is defined (gt 0)
+        if (maxExecutionDiff > 0) {
+            // Check if the same question node was executed before, if yes
+            // calculate the question diff. last step - recent step
+            let questionDiff = 0;
+            if (executionAmount > 1) {
+                // Calculate the question diff from the first lastExecutedAt				
+                questionDiff = executionDiff - lastExecutionMarker;
+            }
+            let validateAnswer = questionDiff <= maxExecutionDiff;
+            // If we don't want to validate due to an exceeded forget question
+            // threshold, we set setLastExecutionMarker to 0
+            if (!validateAnswer) {
+                currentNodeExecutionAmount = 0;
+                api.setExecutionAmount(nodeId, 1);
+            }
+        }
+        // #region 1 AnswerExistsInContext
         // if the user has chose to skip the question in case the context already
         // exists, we will just skip the question
         if (config.storeResultInContext && config.skipIfResultInContext) {
@@ -270,50 +1060,340 @@ exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
                 location = BaseContext_1.BaseContext.findLocationPathStateless(splits, true, location);
                 target = splits[splits.length - 1];
             }
-            if (location[target]) {
+            if (location[target] !== null && location[target] !== undefined) {
+                api.setLastExecutionMarker(nodeId, -1);
                 api.resetExecutionAmount(nodeId);
+                api.deleteSystemContext('activeQuestion');
                 return;
             }
         }
+        // #endregion 1 AnswerExistsInContext
+        // #region 2 FirstTimeNodeIsHit
         // if it's the first execution and you don't force evaluation on first execution, ask the question
         if (isFirstExecution && !parseResultOnEntry) {
             say_1.SAY.function({ cognigy, childConfigs: [], nodeId, config: { say } });
-            // if type is date and we don't hide the picker, display it as well
-            if (type === "date" && !datepicker_hidePicker)
+            if (config.type === "date" && !config.datepicker_hidePicker) {
                 datepickerUtils_1.showDatePicker(cognigy, config);
+            }
+            api.setLastExecutionMarker(nodeId, cognigy.input.execution);
             api.setNextNode(nodeId);
             api.stopExecution();
             return;
         }
+        // #endregion 2 FirstTimeNodeIsHit
         // if we're in a subsequent execution or we want to parse results
         // immediately on entry, continue with evaluation
         let result = evaluateQuestionAnswer_1.evaluateQuestionAnswer({ cognigy, config });
+        // #endregion 4 RunQuestionAnswerValidation
+        // #region 4.1 ResultLocationHandling
+        // if a result location was specified, try to get the result from that location 
+        // if the location returns a falsey value, the answer is invalid
+        if (resultLocation && result) {
+            result = api.parseCognigyScriptResultLocation(resultLocation);
+            // If we want detailed results, augment the result object accordingly
+            if (storeDetailedResults && result !== null && result !== undefined) {
+                result = {
+                    "value": result,
+                    "question": getQuestionText_1.getQuestionText(config),
+                    "timestamp": cognigy.input.currentTime.ISODate,
+                    "answer": cognigy.input.text,
+                    "answerData": cognigy.input.data
+                };
+            }
+        }
+        // #endregion 4.1 ResultLocationHandling
+        const isValid = validateQuestionAnswer_1.validateQuestionAnswer(cognigy, config);
         // hard check against null & undefined, because result can be 0 or false
-        if (result !== null && result !== undefined) {
-            if (storeResultInContext && contextKey) {
-                // check whether contextKey or inputKey is a deep query and set
-                // storage location accordingly
-                let location = context;
-                let target = contextKey;
-                // this is a deep query
-                if (target.indexOf(".") > -1) {
-                    const splits = target.split(".");
-                    location = BaseContext_1.BaseContext.findLocationPathStateless(splits, true, location);
-                    target = splits[splits.length - 1];
-                }
-                location[target] = result;
+        if (result !== null && result !== undefined && isValid) {
+            // #region 5.1 AnswerIsValid
+            if (reconfirmationBehaviour === "reconfirm" && reconfirmationQuestion) {
+                // #region 5.1.1 ReconfirmationQuestion
+                // remember the given answer in the activeQuestion object
+                activeQuestion.tentativeAnswer = result;
+                // remember a shortform of the given answer in the activeQuestion object
+                activeQuestion.tentativeAnswerShortform = generateAnswerShortForm_1.generateAnswerShortForm(type, result, cognigy.input.text);
+                // Output reconfirmationQuestion
+                say_1.SAY.function({ cognigy, childConfigs: [], nodeId, config: { say: { type: "text", text: [reconfirmationQuestion.replace("[ANSWER]", activeQuestion.tentativeAnswerShortform)] } } });
+                // remember that we are in reconfirmation mode and stop
+                api.setSystemContext("reconfirmationQuestionInProgress", true);
+                // we need to store the input, to be able to restore it afterwards
+                // since we need information like intentLevel.
+                api.setSystemContext("reconfirmationQuestionInput", input);
+                api.setNextNode(nodeId);
+                api.stopExecution();
+                // #endregion 5.1.1 ReconfirmationQuestion
             }
             else {
-                input.result = result;
+                // #region 5.1.2 StoreAnswerInContextOrInput
+                storeQuestionAnswer_1.storeQuestionAnswer({ context, contextKey, input, result, storeResultInContext });
+                // #endregion 5.1.2 StoreAnswerInContextOrInput
+                // #region 5.1.3 StoreAnswerInProfile
+                // if profile storage is requested, also store in contact profile
+                if (storeInContactProfile && profile && profileKey) {
+                    profile[profileKey] = (storeDetailedResults) ? result.value : result;
+                }
+                // #endregion 5.1.3 StoreAnswerInProfile
+                // #region 5.1.4 SetMarkersAndContinue
+                api.setLastExecutionMarker(nodeId, -1);
+                api.resetExecutionAmount(nodeId);
+                api.deleteSystemContext('activeQuestion');
+                // #endregion 5.1.4 SetMarkersAndContinue
             }
-            // if profile storage is requested, also store in contact profile
-            if (storeInContactProfile && profile && profileKey)
-                profile[profileKey] = (storeDetailedResults) ? result.value : result;
-            api.resetExecutionAmount(nodeId);
             return;
+            // #endregion 5.1 AnswerIsValid
         }
-        else {
-            if (validationMessage && !isFirstExecution) {
+        else { // Answer was INVALID
+            // #region 5.2 AnswerIsInvalid
+            let sayReprompt = true;
+            let escalatedInIntent = false;
+            // #region 5.2.1 EscalationOnIntent
+            // Process escalation on intents
+            if (escalateIntentsAction && escalateIntentsAction !== "none") {
+                const lastEscalation = api.getSystemContext(`lastEscalation-${nodeId}`);
+                if (lastEscalation && lastEscalation === cognigy.input.execution) {
+                    // escalation already happened on this execution - don't escalate again
+                    sayReprompt = false;
+                }
+                else if (input.intent && input.intentScore >= escalateIntentsThreshold && escalateIntentsValidIntents.indexOf(input.intent) > -1) {
+                    // User has triggered intent escalation					
+                    escalatedInIntent = true;
+                    activeQuestion.escalationCount++;
+                    switch (escalateIntentsAction) {
+                        case "goto":
+                            if (!escalateIntentsGotoTarget) {
+                                throw new Error("GoTo Target is required");
+                            }
+                            // remember when this escalation happened
+                            api.setSystemContext(`lastEscalation-${nodeId}`, cognigy.input.execution);
+                            await goTo_1.GO_TO.function({
+                                cognigy,
+                                childConfigs: [],
+                                nodeId,
+                                config: {
+                                    flowNode: escalateIntentsGotoTarget,
+                                    absorbContext: false,
+                                    executionMode: escalateIntentsGotoExecutionMode,
+                                    injectedText: escalateIntentsInjectedText,
+                                    injectedData: Object.assign({}, input.data, escalateIntentsInjectedData),
+                                    parseIntents: false,
+                                    parseKeyphrases: false
+                                }
+                            });
+                            return;
+                        case "execute":
+                            if (!escalateIntentsExecuteTarget) {
+                                throw new Error("Execute Flow Target is required");
+                            }
+                            // set myself as next Node on the stack, so we can return to me
+                            api.setNextNode(nodeId);
+                            // remember when this escalation happened
+                            api.setSystemContext(`lastEscalation-${nodeId}`, cognigy.input.execution);
+                            // execute chosen Flow
+                            await executeFlow_1.EXECUTE_FLOW.function({
+                                cognigy,
+                                childConfigs: [],
+                                nodeId,
+                                config: {
+                                    flowNode: escalateIntentsExecuteTarget,
+                                    absorbContext: false,
+                                    parseIntents: false,
+                                    parseKeyphrases: false
+                                }
+                            });
+                            return;
+                        case "skip":
+                            input.result = {
+                                "skipped": true,
+                                "intent": input.intent,
+                                "reason": "Intent escalation was triggered and question was skipped"
+                            };
+                            if (storeResultInContext && contextKey) {
+                                // check whether contextKey or inputKey is a deep query and set
+                                // storage location accordingly
+                                let location = context;
+                                let target = contextKey;
+                                // this is a deep query
+                                if (target.indexOf(".") > -1) {
+                                    const splits = target.split(".");
+                                    location = BaseContext_1.BaseContext.findLocationPathStateless(splits, true, location);
+                                    target = splits[splits.length - 1];
+                                }
+                                location[target] = {
+                                    "skipped": true,
+                                    "intent": input.intent,
+                                    "reason": "Intent escalation was triggered and question was skipped"
+                                };
+                            }
+                            api.setLastExecutionMarker(nodeId, -1);
+                            api.resetExecutionAmount(nodeId);
+                            api.deleteSystemContext('activeQuestion');
+                            return;
+                        case "text":
+                            say_1.SAY.function({
+                                cognigy,
+                                childConfigs: [],
+                                nodeId,
+                                config: { say: escalateIntentsMessage }
+                            });
+                            if (escalateIntentsRepromptPrevention) {
+                                sayReprompt = false;
+                            }
+                            break;
+                        case "handover":
+                            resetNodeState_1.resetNodeState(api, nodeId);
+                            await service_1.HANDOVER_V2.function({
+                                cognigy,
+                                childConfigs: [],
+                                nodeId,
+                                config: {
+                                    text: escalateIntentsHandoverText,
+                                    repeatHandoverMessage: escalateIntentsRepeatHandoverMessage,
+                                    cancelIntent: escalateIntentsHandoverCancelIntent,
+                                    quickReply: escalateIntentsHandoverQuickReply,
+                                    chatwootInboxId: escalateIntentsHandoverChatwootInboxId,
+                                    liveAgentInboxId: escalateIntentsHandoverLiveAgentInboxId,
+                                    salesforcePrechatEntities: escalateIntentsHandoverSalesforcePrechatEntities,
+                                    salesforcePrechatDetails: escalateIntentsHandoverSalesforcePrechatDetails
+                                }
+                            });
+                            return;
+                    }
+                }
+            }
+            // #endregion 5.2.1 EscalationOnIntent
+            // #region 5.2.2 EscalationOnAnswers
+            if ((!escalatedInIntent && escalatedInIntent != undefined) && escalateAnswersAction && escalateAnswersAction !== "none") {
+                // the user set special escalation handling in case multiple wrong answers were provided
+                // this is only done if intent escalation didnt happen
+                const lastEscalation = api.getSystemContext(`lastEscalation-${nodeId}`);
+                let addEscalationText = false;
+                if (escalateAnswersOnce) {
+                    addEscalationText = currentNodeExecutionAmount === escalateAnswersThreshold;
+                }
+                else {
+                    addEscalationText = currentNodeExecutionAmount >= escalateAnswersThreshold;
+                }
+                // either we escalate only once on the threshold or always from the threshold on, depending on what was set
+                if (lastEscalation && lastEscalation === cognigy.input.execution) {
+                    // escalation already happened on this execution - don't escalate again
+                    sayReprompt = false;
+                }
+                else if (addEscalationText) {
+                    // User has given enough wrong answers to trigger the threshold
+                    activeQuestion.escalationCount++;
+                    switch (escalateAnswersAction) {
+                        case "goto":
+                            if (!escalateAnswersGotoTarget) {
+                                throw new Error("GoTo Target is required");
+                            }
+                            // remember when this escalation happened
+                            api.setSystemContext(`lastEscalation-${nodeId}`, cognigy.input.execution);
+                            await goTo_1.GO_TO.function({
+                                cognigy,
+                                childConfigs: [],
+                                nodeId,
+                                config: {
+                                    flowNode: escalateAnswersGotoTarget,
+                                    absorbContext: false,
+                                    executionMode: escalateAnswersGotoExecutionMode,
+                                    injectedText: escalateAnswersInjectedText,
+                                    injectedData: Object.assign({ "escalation": api.getExecutionAmount(nodeId) - escalateAnswersThreshold }, input.data, escalateAnswersInjectedData),
+                                    parseIntents: false,
+                                    parseKeyphrases: false
+                                }
+                            });
+                            return;
+                        case "execute":
+                            if (!escalateAnswersExecuteTarget) {
+                                throw new Error("Execute Flow Target is required");
+                            }
+                            // set myself as next Node on the stack, so we can return to me
+                            api.setNextNode(nodeId);
+                            // remember when this escalation happened
+                            api.setSystemContext(`lastEscalation-${nodeId}`, cognigy.input.execution);
+                            // execute chosen Flow
+                            await executeFlow_1.EXECUTE_FLOW.function({
+                                cognigy,
+                                childConfigs: [],
+                                nodeId,
+                                config: {
+                                    flowNode: escalateAnswersExecuteTarget,
+                                    absorbContext: false,
+                                    parseIntents: false,
+                                    parseKeyphrases: false
+                                }
+                            });
+                            return;
+                        case "skip":
+                            input.result = {
+                                "skipped": true,
+                                "reason": "Too many incorrect answers were given and question was skipped"
+                            };
+                            if (storeResultInContext && contextKey) {
+                                // check whether contextKey or inputKey is a deep query and set
+                                // storage location accordingly
+                                let location = context;
+                                let target = contextKey;
+                                // this is a deep query
+                                if (target.indexOf(".") > -1) {
+                                    const splits = target.split(".");
+                                    location = BaseContext_1.BaseContext.findLocationPathStateless(splits, true, location);
+                                    target = splits[splits.length - 1];
+                                }
+                                location[target] = {
+                                    "skipped": true,
+                                    "reason": "Too many incorrect answers were given and question was skipped"
+                                };
+                            }
+                            api.setLastExecutionMarker(nodeId, -1);
+                            api.resetExecutionAmount(nodeId);
+                            api.deleteSystemContext('activeQuestion');
+                            return;
+                        case "text":
+                            say_1.SAY.function({
+                                cognigy,
+                                childConfigs: [],
+                                nodeId,
+                                config: { say: escalateAnswersMessage }
+                            });
+                            if (escalateAnswersRepromptPrevention) {
+                                sayReprompt = false;
+                            }
+                            break;
+                        case "handover":
+                            resetNodeState_1.resetNodeState(api, nodeId);
+                            await service_1.HANDOVER_V2.function({
+                                cognigy,
+                                childConfigs: [],
+                                nodeId,
+                                config: {
+                                    text: escalateAnswersHandoverText,
+                                    cancelIntent: escalateAnswersHandoverCancelIntent,
+                                    repeatHandoverMessage: escalateAnswersRepeatHandoverMessage,
+                                    quickReply: escalateAnswersHandoverQuickReply,
+                                    chatwootInboxId: escalateAnswersHandoverChatwootInboxId,
+                                    liveAgentInboxId: escalateAnswersHandoverLiveAgentInboxId,
+                                    salesforcePrechatEntities: escalateAnswersHandoverSalesforcePrechatEntities,
+                                    salesforcePrechatDetails: escalateAnswersHandoverSalesforcePrechatDetails
+                                }
+                            });
+                            return;
+                    }
+                }
+            }
+            // #endregion 5.2.2 EscalationOnAnswers
+            // #region 5.2.3 Reprompt
+            // check if there is an extra condition defined for reprompts and check whether it was truthy
+            if (sayReprompt && repromptCondition) {
+                sayReprompt = !!api.parseCognigyScriptCondition(repromptCondition);
+            }
+            // if we decided to skip the reprompt on intent and there
+            // is an intent, don't say it
+            if (skipRepromptOnIntent && cognigy.input.intent) {
+                sayReprompt = false;
+            }
+            if (validationMessage && !isFirstExecution && sayReprompt) {
+                activeQuestion.repromptCount++;
                 /* Output Reprompt Message */
                 say_1.SAY.function({ cognigy, childConfigs: [], nodeId, config: { say: { type: "text", text: [validationMessage] } } });
                 /* If repeat toggle is on, also output question (and maybe datepicker) again */
@@ -324,9 +1404,9 @@ exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
                         nodeId,
                         config: { say }
                     });
-                    // if type is date and we don't hide the picker, display it
-                    if (type === "date" && !datepicker_hidePicker)
+                    if (config.type === "date" && !config.datepicker_hidePicker) {
                         datepickerUtils_1.showDatePicker(cognigy, config);
+                    }
                 }
             }
             else {
@@ -337,12 +1417,17 @@ exports.QUESTION = createNodeDescriptor_1.createNodeDescriptor({
                     nodeId,
                     config: { say }
                 });
-                // if type is date and we don't hide the picker, display it
-                if (type === "date" && !datepicker_hidePicker)
+                if (config.type === "date" && !config.datepicker_hidePicker) {
                     datepickerUtils_1.showDatePicker(cognigy, config);
+                }
             }
+            // #endregion 5.2.3 Reprompt
+            // #region 5.2.4 SetNextNodeAndStop
+            api.setLastExecutionMarker(nodeId, cognigy.input.execution);
             api.setNextNode(nodeId);
             api.stopExecution();
+            // #endregion 5.2.4 SetNextNodeAndStop
+            // #endregion 5.2 AnswerIsInvalid
         }
     }
 });