@cognigy/rest-api-client 0.11.0 → 0.13.0

package/build/shared/charts/descriptors/nlu/utils/patternMatcher.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patternMatcher = void 0;
+const cognigySlots_1 = require("../../../../interfaces/cognigySlots");
+const systemSlots = new Set(cognigySlots_1.cognigySystemSlots);
+/**
+ * Finds compound slots using pattern inside the user input
+ * @param input Cognigy Input Object
+ * @param patterns The patterns to check for
+ * @param patternGroupName Name for the compound group
+ * @param detailedCompoundSlots Store detailed results for compound slots
+ * @param tagExistingSlots Tag existing slots
+ * @param createNewSlots Create new slots from tags
+ * @param nluResult result from cognigy NLU since there was an alternative input
+ */
+const patternMatcher = (params) => {
+    var _a;
+    const { input, patternGroupName, detailedCompoundSlots, tagExistingSlots, createNewSlots, nluResult, useFullSystemslotText } = params;
+    let { patterns } = params;
+    // prune patterns if more than 20
+    if (patterns.length > 20) {
+        patterns = patterns.slice(0, 20);
+    }
+    // firstly sort array to start with the longest patterns, as those will win
+    patterns.sort((a, b) => {
+        return b.length - a.length;
+    });
+    // we use let because we strip out found phrases later
+    let inputText = nluResult.text || input.text; // ci.processText
+    let inputSlots = nluResult.slots || input.slots;
+    const detailedSlots = ((_a = input.nlu) === null || _a === void 0 ? void 0 : _a.detailedSlots) || {};
+    const regexPatterns = [];
+    // go through patterns and create regex versions of each that is not empty string
+    patterns.forEach((pattern) => {
+        if (pattern) {
+            // set parsedPattern to pattern in case there are no slots
+            let parsedPattern = pattern;
+            // match all mentioned slots in the pattern
+            const foundSlots = pattern.match(/\@[\w>]+/g);
+            const tags = [];
+            const slots = [];
+            // if there are slots, process them
+            if (Array.isArray(foundSlots) && foundSlots.length > 0) {
+                foundSlots.forEach((slot) => {
+                    // splits tags from slots
+                    const split = slot.split(">");
+                    const slotName = split[0].replace("@", "");
+                    slots.push(slotName);
+                    // if there is a tag (SLOT>TAG), remember it
+                    if (split.length === 2)
+                        tags.push(split[1]);
+                    else
+                        tags.push("");
+                    const slotValues = [];
+                    if (inputSlots[slotName]) {
+                        if (systemSlots.has(slotName)) {
+                            processFoundSystemSlots(useFullSystemslotText, inputSlots, detailedSlots, slotName, slotValues);
+                        }
+                        else {
+                            inputSlots[slotName].forEach((s) => {
+                                // it's important to use the synonym, as this is the text that was actually found
+                                slotValues.push(s.synonym);
+                            });
+                        }
+                        const slotRegex = slotValues.join("|");
+                        // replace the slots name with the list of actually found entites for this slot
+                        parsedPattern = parsedPattern.replace(new RegExp(`${slot}`, "g"), `(${slotRegex})`);
+                    }
+                });
+            }
+            if (parsedPattern != "()") {
+                regexPatterns.push({
+                    "pattern": pattern,
+                    "parsedPattern": parsedPattern,
+                    "tags": tags,
+                    "slots": slots
+                });
+            }
+        }
+    });
+    const compoundGroups = [];
+    // go through all created patterns and test them
+    regexPatterns.forEach((pattern) => {
+        let result;
+        const regExp = new RegExp(pattern.parsedPattern, "gi");
+        const regexMatches = [];
+        while (result = regExp.exec(inputText)) {
+            regexMatches.push(result);
+        }
+        regexMatches.forEach((m) => {
+            inputText = inputText.replace(m[0], "");
+        });
+        if (regexMatches.length > 0) {
+            // we found a match for this pattern!
+            regexMatches.forEach((matches, mi) => {
+                // set up a compoundGroup scaffold, just in case we need it
+                const matchedPatternGroup = {
+                    "matchedPhrase": matches[0],
+                    "components": []
+                };
+                if (!detailedCompoundSlots)
+                    delete matchedPatternGroup.components;
+                // iterate through matches, starting at the first group result ([0] is the full match)
+                for (let i = 1; i < matches.length; i++) {
+                    let originalSlot = null;
+                    const match = matches[i];
+                    const slot = pattern.slots[i - 1];
+                    if (systemSlots.has(slot)) {
+                        originalSlot = handleSystemSlotMatches(useFullSystemslotText, match, slot, inputSlots, detailedSlots);
+                    }
+                    else {
+                        originalSlot = inputSlots[pattern.slots[i - 1]].find(e => (e.synonym) ? e.synonym.toLowerCase() === matches[i].toLowerCase() : false);
+                    }
+                    // create compound groups
+                    if (detailedCompoundSlots) {
+                        const components = {
+                            "slot": pattern.slots[i - 1],
+                            "value": originalSlot.keyphrase || originalSlot
+                        };
+                        if (pattern.tags[i - 1])
+                            components["tag"] = pattern.tags[i - 1];
+                        else
+                            components["tag"] = null;
+                        matchedPatternGroup.components.push(components);
+                    }
+                    else {
+                        if (pattern.tags[i - 1])
+                            matchedPatternGroup[pattern.tags[i - 1]] = (originalSlot === null || originalSlot === void 0 ? void 0 : originalSlot.keyphrase) || originalSlot;
+                        else
+                            matchedPatternGroup[pattern.slots[i - 1]] = originalSlot || originalSlot.keyphrase;
+                    }
+                    if (pattern.tags[i - 1]) {
+                        if (createNewSlots) {
+                            if (inputSlots[pattern.tags[i - 1]]) {
+                                inputSlots[pattern.tags[i - 1]].push(originalSlot);
+                            }
+                            else
+                                inputSlots[pattern.tags[i - 1]] = [originalSlot];
+                        }
+                        if (tagExistingSlots) {
+                            inputSlots[pattern.slots[i - 1]].forEach((s) => {
+                                var _a, _b;
+                                if (((_a = s === null || s === void 0 ? void 0 : s.synonym) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === ((_b = matches[i]) === null || _b === void 0 ? void 0 : _b.toLowerCase())) {
+                                    s["tags"] = (Array.isArray(s["tags"])) ? s["tags"].push(pattern.tags[i - 1]) : [pattern.tags[i - 1]];
+                                }
+                            });
+                        }
+                    }
+                }
+                compoundGroups.push(matchedPatternGroup);
+            });
+        }
+    });
+    if (!input["matchedPatterns"])
+        input["matchedPatterns"] = {};
+    if (compoundGroups && Array.isArray(compoundGroups) && compoundGroups.length > 0) {
+        input["matchedPatterns"][patternGroupName] = compoundGroups;
+    }
+    if (compoundGroups && compoundGroups.length === 0 && (typeof input["matchedPatterns"] !== 'object' || Object.keys(input["matchedPatterns"]).length === 0))
+        delete input["matchedPatterns"];
+    return input;
+};
+exports.patternMatcher = patternMatcher;
+const processFoundSystemSlots = (useFullSystemslotText, inputSlots, detailedSlots, slotName, slotValues) => {
+    var _a;
+    if (useFullSystemslotText) {
+        // we use the detailed system slots to get the text value
+        (_a = detailedSlots[slotName]) === null || _a === void 0 ? void 0 : _a.forEach((s) => {
+            slotValues.push(s.text);
+        });
+    }
+    else if (inputSlots[slotName]) {
+        switch (slotName) {
+            case "DATE":
+                inputSlots.DATE.forEach((s) => {
+                    if (s.start)
+                        slotValues.push(s["text"]);
+                });
+                break;
+            case "NUMBER":
+                inputSlots.NUMBER.forEach((s) => {
+                    slotValues.push(s);
+                });
+                break;
+            case "DURATION":
+                inputSlots.DURATION.forEach((s) => {
+                    slotValues.push(s["years"] || s["months"] || s["weeks"] || s["days"] || s["hours"] || s["minutes"] || s["seconds"]);
+                });
+                break;
+            case "TEMPERATURE":
+                inputSlots.TEMPERATURE.forEach((s) => {
+                    slotValues.push(s.value);
+                });
+                break;
+            case "AGE":
+                inputSlots.AGE.forEach((s) => {
+                    slotValues.push(s.value);
+                });
+                break;
+            case "PERCENTAGE":
+                inputSlots.PERCENTAGE.forEach((s) => {
+                    slotValues.push(s + "%");
+                    slotValues.push(s + " percent");
+                });
+                break;
+            case "EMAIL":
+                inputSlots.EMAIL.forEach((s) => {
+                    slotValues.push(s);
+                });
+                break;
+            case "URL":
+                inputSlots.URL.forEach((s) => {
+                    slotValues.push(s);
+                });
+                break;
+            case "MONEY":
+                inputSlots.MONEY.forEach((s) => {
+                    slotValues.push(s.value);
+                });
+                break;
+            case "DISTANCE":
+                inputSlots.DISTANCE.forEach((s) => {
+                    slotValues.push(s.value);
+                });
+                break;
+        }
+    }
+};
+const handleSystemSlotMatches = (useFullSystemslotText, match, slotName, inputSlots, detailedSlots) => {
+    if (useFullSystemslotText) {
+        const matchedSlot = detailedSlots[slotName].find(e => (e["text"] === match));
+        if (!matchedSlot) {
+            return;
+        }
+        switch (slotName) {
+            case "NUMBER":
+            case "PERCENTAGE":
+                return matchedSlot.data.value;
+            case "DATE":
+                return Object.assign(Object.assign({}, matchedSlot.data), { text: matchedSlot.text });
+            default:
+                return matchedSlot.data;
+        }
+    }
+    else {
+        switch (slotName) {
+            case "PERCENTAGE":
+                return Number(match.replace(new RegExp("[^0-9]", "gi"), ""));
+            case "TEMPERATURE":
+            case "AGE":
+            case "NUMBER":
+            case "MONEY":
+            case "DISTANCE":
+            case "DURATION":
+                return Number(match);
+            case "DATE":
+                // @ts-ignore
+                const dateSlot = inputSlots.DATE.find(e => (e["text"] === match));
+                return (dateSlot === null || dateSlot === void 0 ? void 0 : dateSlot.start) || (dateSlot === null || dateSlot === void 0 ? void 0 : dateSlot.end);
+            default:
+                return match;
+        }
+    }
+};
+//# sourceMappingURL=patternMatcher.js.map

package/build/shared/charts/descriptors/placeholder.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PLACEHOLDER = void 0;
 /* Custom modules */
 const createNodeDescriptor_1 = require("../createNodeDescriptor");
-exports.PLACEHOLDER = createNodeDescriptor_1.createNodeDescriptor({
+exports.PLACEHOLDER = (0, createNodeDescriptor_1.createNodeDescriptor)({
     type: "placeholder",
     defaultLabel: "Placeholder",
     summary: "This node is used as a Placeholder.",

package/build/shared/charts/descriptors/requiredFields.js

@@ -4,7 +4,7 @@ exports.REQUIRED_FIELDS = void 0;
 /* Custom modules */
 const createNodeDescriptor_1 = require("../createNodeDescriptor");
 const mongoDBConnection_1 = require("./connectionNodes/mongoDB/mongoDBConnection");
-exports.REQUIRED_FIELDS = createNodeDescriptor_1.createNodeDescriptor({
+exports.REQUIRED_FIELDS = (0, createNodeDescriptor_1.createNodeDescriptor)({
     type: "requiredFields",
     defaultLabel: "Required Fields",
     appearance: {

package/build/shared/charts/descriptors/service/checkAgentAvailability.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHECK_AGENT_AVAILABILITY = void 0;
+/* Custom modules */
+const createNodeDescriptor_1 = require("../../createNodeDescriptor");
+/**
+ * Node name: 'checkAgentAvailability'
+ *
+ * Purpose:
+ * Check if agents are available for handover
+ */
+exports.CHECK_AGENT_AVAILABILITY = (0, createNodeDescriptor_1.createNodeDescriptor)({
+    type: "checkAgentAvailability",
+    defaultLabel: "Check Agent Availability",
+    summary: "Get the number of available agents for handover",
+    appearance: {
+        showIcon: false,
+    },
+    tags: ["service"],
+    fields: [
+        {
+            key: "chatwootInboxId",
+            type: "cognigyText",
+            label: "Chatwoot Inbox Id",
+            description: "Inbox Id in Chatwoot"
+        },
+        {
+            key: "liveAgentInboxId",
+            type: "cognigyText",
+            label: "Live Agent Inbox Id",
+            description: "Inbox Id in Live Agent"
+        },
+        {
+            key: "genesysCloudSkills",
+            type: "textArray",
+            label: "Skills",
+            description: "A list of skills that should be used to filter the available agents"
+        },
+        {
+            key: "genesysCloudProfileSkills",
+            type: "textArray",
+            label: "Profile Skills",
+            description: "A list of profile skills that should be used to filter the available agents"
+        },
+        {
+            key: "genesysCloudLanguageSkills",
+            type: "textArray",
+            label: "Language Skills",
+            description: "A list of language skills that should be used to filter the available agents"
+        },
+        {
+            key: "storeLocation",
+            type: "select",
+            label: "Where to store the result",
+            params: {
+                options: [
+                    {
+                        label: "Input",
+                        value: "input"
+                    },
+                    {
+                        label: "Context",
+                        value: "context"
+                    }
+                ],
+                required: true
+            },
+            defaultValue: "input"
+        },
+        {
+            key: "inputKey",
+            type: "cognigyText",
+            label: "Input Key to store Result",
+            description: "Where to store the result in the Input object. E.g. input.availableAgents",
+            defaultValue: "availableAgents",
+            condition: {
+                key: "storeLocation",
+                value: "input"
+            }
+        },
+        {
+            key: "contextKey",
+            type: "cognigyText",
+            label: "Context Key to store Result",
+            description: "Where to store the result in the Context object. E.g. context.availableAgents",
+            defaultValue: "availableAgents",
+            condition: {
+                key: "storeLocation",
+                value: "context"
+            }
+        },
+        {
+            key: "abortOnError",
+            type: "toggle",
+            label: "Abort Flow Execution on Error",
+            description: "Aborts Flow Execution on all HTTP status codes > 299",
+            defaultValue: false
+        },
+        {
+            key: "errorLogging",
+            type: "select",
+            label: "Error Logging",
+            description: "Whether to log errors into the Agent Logs",
+            defaultValue: "none",
+            params: {
+                required: true,
+                options: [
+                    {
+                        label: "Don't log errors",
+                        value: "none"
+                    },
+                    {
+                        label: "Log error codes and responses",
+                        value: "basic"
+                    },
+                    {
+                        label: "Log full errors and request payloads",
+                        value: "full"
+                    }
+                ]
+            }
+        },
+        {
+            key: "logWarning",
+            type: "description",
+            label: " ",
+            params: {
+                text: "WARNING: Logging full request payloads may expose sensitive information in the server and agent logs."
+            },
+            condition: {
+                key: "errorLogging",
+                value: "full"
+            }
+        },
+    ],
+    sections: [
+        {
+            key: "chatwootSettings",
+            label: "Chatwoot Settings",
+            defaultCollapsed: true,
+            fields: [
+                "chatwootInboxId",
+            ]
+        },
+        {
+            key: "liveAgentSettings",
+            label: "Live Agent Settings",
+            defaultCollapsed: true,
+            fields: [
+                "liveAgentInboxId",
+            ]
+        },
+        {
+            key: "genesysCloudSettings",
+            label: "Genesys Cloud Settings",
+            defaultCollapsed: true,
+            fields: [
+                "genesysCloudSkills",
+                "genesysCloudProfileSkills",
+                "genesysCloudLanguageSkills"
+            ]
+        },
+        {
+            key: "storage",
+            label: "Storage Options",
+            defaultCollapsed: true,
+            fields: [
+                "storeLocation",
+                "inputKey",
+                "contextKey",
+            ]
+        },
+        {
+            key: "errors",
+            label: "Error Handling",
+            defaultCollapsed: true,
+            fields: [
+                "errorLogging",
+                "logWarning",
+                "abortOnError"
+            ]
+        }
+    ],
+    form: [
+        { type: "section", key: "genesysCloudSettings" },
+        // only render this field if "live agent" is enabled
+        process.env.FEATURE_USE_COGNIGY_LIVE_AGENT === "true" && {
+            type: "section",
+            key: "liveAgentSettings"
+        },
+        { type: "section", key: "chatwootSettings" },
+        // { type: "section", key: "salesforceSettings" }, TODO
+        { type: "section", key: "storage" },
+        { type: "section", key: "errors" },
+    ]
+        .filter(element => !!element),
+    function: async ({ cognigy, config }) => {
+        const { api } = cognigy;
+        // @ts-ignore
+        return await api.checkAgentAvailability({ cognigy, config });
+    }
+});
+//# sourceMappingURL=checkAgentAvailability.js.map

package/build/shared/charts/descriptors/service/handover.js

@@ -9,13 +9,17 @@ const createNodeDescriptor_1 = require("../../createNodeDescriptor");
  * Purpose:
  * Sends a handover request service-handover if the channel is supported
  */
-exports.HANDOVER = createNodeDescriptor_1.createNodeDescriptor({
+exports.HANDOVER = (0, createNodeDescriptor_1.createNodeDescriptor)({
     type: "handover",
     defaultLabel: "Handover",
     summary: "Sends a handover request to an agent",
     appearance: {
         showIcon: false
     },
+    constraints: {
+        placement: {},
+        creatable: false,
+    },
     fields: [
         {
             key: "text",
@@ -52,6 +56,12 @@ exports.HANDOVER = createNodeDescriptor_1.createNodeDescriptor({
             type: "cognigyText",
             label: "Chatwoot Inbox Id",
             description: "Inbox Id in Chatwoot"
+        },
+        {
+            key: "liveAgentInboxId",
+            type: "cognigyText",
+            label: "Live Agent Inbox Id",
+            description: "Inbox Id in Live Agent"
         }
     ],
     sections: [
@@ -62,6 +72,14 @@ exports.HANDOVER = createNodeDescriptor_1.createNodeDescriptor({
             fields: [
                 "chatwootInboxId",
             ]
+        },
+        {
+            key: "liveAgentSettings",
+            label: "Live Agent Settings",
+            defaultCollapsed: true,
+            fields: [
+                "liveAgentInboxId",
+            ]
         }
     ],
     form: [
@@ -71,10 +89,19 @@ exports.HANDOVER = createNodeDescriptor_1.createNodeDescriptor({
         { type: "field", key: "unsupportedChannel" },
         { type: "field", key: "quickReply" },
         { type: "section", key: "chatwootSettings" },
-    ],
+        // only render this field if "live agent" is enabled
+        process.env.FEATURE_USE_COGNIGY_LIVE_AGENT === "true" && {
+            type: "section",
+            key: "liveAgentSettings"
+        },
+    ]
+        .filter(element => !!element),
     tags: ["service", "livechat", "chat", "hand over"],
     function: async ({ cognigy, config, childConfigs, nodeId }) => {
-        const { api } = cognigy;
+        const { api, input } = cognigy;
+        if (input.channel === "adminconsole") {
+            api.output("You are using the deprecated Handover Node. Please find the new Handover to Agent Node in the Node Selection Menu.", null);
+        }
         await api.handover({ cognigy, config, nodeId, childConfigs });
     }
 });