@cognigy/rest-api-client 0.11.0 → 0.13.0

package/build/shared/charts/descriptors/nlu/extractAnswer.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXTRACT_ANSWER = void 0;
+/* Custom modules */
+const createNodeDescriptor_1 = require("../../createNodeDescriptor");
+/**
+ * Node name: 'extractAnswer'
+ *
+ * Purpose:
+ * Answers a question based on a given context with the built-in question answering module
+ */
+exports.EXTRACT_ANSWER = (0, createNodeDescriptor_1.createNodeDescriptor)({
+    type: "extractAnswer",
+    defaultLabel: "Extract Answer",
+    summary: "Answers a question based on a given context with the built-in question answering module",
+    appearance: {
+        showIcon: false
+    },
+    fields: [
+        {
+            key: "text",
+            type: "cognigyText",
+            label: "Text",
+            defaultValue: ""
+        },
+        {
+            key: "question",
+            type: "cognigyText",
+            label: "Question",
+            params: {
+                required: true
+            }
+        },
+        {
+            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.extractAnswer",
+            defaultValue: "extractAnswer",
+            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.extractAnswer",
+            defaultValue: "extractAnswer",
+            condition: {
+                key: "storeLocation",
+                value: "context"
+            }
+        },
+    ],
+    sections: [
+        {
+            key: "storage",
+            label: "Storage Options",
+            defaultCollapsed: true,
+            fields: [
+                "storeLocation",
+                "inputKey",
+                "contextKey",
+            ]
+        },
+    ],
+    form: [
+        { type: "field", key: "text" },
+        { type: "field", key: "question" },
+        { type: "field", key: "maxTextLength" },
+        { type: "section", key: "storage" },
+    ],
+    preview: {
+        key: "text",
+        type: "text",
+    },
+    tags: ["nlu"],
+    function: async (extractAnswerParams) => {
+        const { cognigy, config } = extractAnswerParams;
+        const { api } = cognigy;
+        const { question, storeLocation, contextKey, inputKey } = config;
+        if (!question) {
+            throw new Error("Unable to answer question. Question is missing.");
+        }
+        if (storeLocation === "context" && !contextKey) {
+            throw new Error("Unable to answer question. Context Key is missing.");
+        }
+        if (storeLocation === "input" && !inputKey) {
+            throw new Error("Unable to answer question. Input Key is missing.");
+        }
+        return await api.extractAnswer(extractAnswerParams);
+    }
+});
+//# sourceMappingURL=extractAnswer.js.map

package/build/shared/charts/descriptors/nlu/fuzzySearch.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FUZZY_SEARCH = void 0;
+const createNodeDescriptor_1 = require("../../createNodeDescriptor");
+const objectSizeValidator_1 = require("../../../helper/objectSizeValidator");
+const getFuzzySearchMaxObjectSizeInBytes = () => {
+    return parseInt(process.env.FUZZYSEARCH_MAX_OBJECT_SIZE) || 524288;
+};
+exports.FUZZY_SEARCH = (0, createNodeDescriptor_1.createNodeDescriptor)({
+    type: "fuzzySearch",
+    defaultLabel: "Fuzzy Search",
+    summary: "Performs a fuzzy search on a given collection of source data",
+    preview: {
+        key: "searchPattern",
+        type: "text"
+    },
+    tags: ["nlu", "fuzzy", "search"],
+    fields: [
+        {
+            key: "searchPattern",
+            label: "Search Pattern",
+            description: "The pattern to search for",
+            type: "cognigyText",
+            params: {
+                required: true
+            }
+        },
+        {
+            key: "items",
+            label: "Source Data",
+            description: "An array of type string or object to search through..",
+            type: "json",
+            params: {
+                required: true
+            },
+            defaultValue: `[
+	"apple",
+	"orange",
+	"banana",
+	"pear"
+]`
+        },
+        {
+            key: "isCaseSensitive",
+            label: "Is Case Sensitive",
+            defaultValue: false,
+            type: "toggle",
+            description: "Indicates whether comparisons should be case sensitive"
+        },
+        {
+            key: "includeScore",
+            label: "Include Score",
+            defaultValue: true,
+            type: "toggle",
+            description: "Whether the score should be included in the result set. A score of 1 indicates a perfect match, while a score of 0 indicates a complete mismatch"
+        },
+        {
+            key: "includeMatches",
+            label: "Include Matches",
+            defaultValue: false,
+            type: "toggle",
+            description: "Whether the matches should be included in the result set. When true, each record in the result set will include the indices of the matched characters."
+        },
+        {
+            key: "minMatchCharLength",
+            label: "Minimum Characters",
+            defaultValue: 1,
+            type: "number",
+            description: "Only the matches whose length exceeds this value will be returned.",
+            params: {
+                min: 1,
+                max: 100
+            }
+        },
+        {
+            key: "shouldSort",
+            label: "Should Sort",
+            defaultValue: true,
+            type: "toggle",
+            description: "Whether to sort the result list, by score."
+        },
+        {
+            key: "findAllMatches",
+            label: "Find All Matches",
+            defaultValue: true,
+            type: "toggle",
+            description: "When activated, the matching function will continue to the end of a search pattern even if a perfect match has already been located in the string."
+        },
+        {
+            key: "location",
+            label: "Location",
+            defaultValue: 0,
+            type: "number",
+            description: "Determines approximately where in the text is the pattern expected to be found.",
+            params: {
+                min: 0,
+                max: 100
+            }
+        },
+        {
+            key: "threshold",
+            label: "Threshold",
+            defaultValue: 0.1,
+            type: "slider",
+            description: "At what point does the match algorithm give up. A threshold of 1.0 requires a perfect match (of both letters and location), a threshold of 0.0 would match anything.",
+            params: {
+                min: 0,
+                max: 1,
+                step: 0.1
+            }
+        },
+        {
+            key: "distance",
+            label: "Distance",
+            defaultValue: 100,
+            type: "number",
+            description: "Determines how close the match must be to the fuzzy location (specified by location).",
+            params: {
+                min: 0,
+                max: 1000
+            }
+        },
+        {
+            key: "ignoreLocation",
+            label: "Ignore Location",
+            defaultValue: true,
+            type: "toggle",
+            description: "When activated, search will ignore location and distance, so it won't matter where in the string the pattern appears."
+        },
+        {
+            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",
+            defaultValue: "search",
+            condition: {
+                key: "storeLocation",
+                value: "input"
+            }
+        },
+        {
+            key: "contextKey",
+            type: "cognigyText",
+            label: "Context Key to store Result",
+            defaultValue: "search",
+            condition: {
+                key: "storeLocation",
+                value: "context"
+            }
+        }
+    ],
+    sections: [
+        {
+            key: "storageOption",
+            label: "Storage Option",
+            defaultCollapsed: true,
+            fields: [
+                "storeLocation",
+                "inputKey",
+                "contextKey"
+            ]
+        },
+        {
+            key: "basicOptions",
+            label: "Basic Options",
+            defaultCollapsed: true,
+            fields: [
+                "isCaseSensitive",
+                "includeScore",
+                "includeMatches",
+                "minMatchCharLength",
+                "shouldSort",
+                "findAllMatches",
+            ]
+        },
+        {
+            key: "fuzzyOptions",
+            label: "Fuzzy Matching Options",
+            defaultCollapsed: true,
+            fields: [
+                "location",
+                "threshold",
+                "distance",
+                "ignoreLocation",
+            ]
+        }
+    ],
+    form: [
+        { type: "field", key: "searchPattern" },
+        { type: "field", key: "items" },
+        { type: "section", key: "basicOptions" },
+        { type: "section", key: "fuzzyOptions" },
+        { type: "section", key: "storageOption" }
+    ],
+    function: async ({ cognigy, config }) => {
+        const { api } = cognigy;
+        const { searchPattern, items, distance, findAllMatches, ignoreLocation, includeMatches, includeScore, isCaseSensitive, location, minMatchCharLength, shouldSort, threshold, storeLocation, inputKey, contextKey } = config;
+        if (!searchPattern)
+            throw new Error("No search pattern provided.");
+        if (!items)
+            throw new Error("No source data provided.");
+        try {
+            // reverse threshold as fuse requires it inverse (0 = perfect match, 1 = matches everything)
+            const newThreshold = 1 - threshold;
+            const options = {
+                distance,
+                findAllMatches,
+                ignoreLocation,
+                includeMatches,
+                includeScore,
+                isCaseSensitive,
+                location,
+                minMatchCharLength,
+                shouldSort,
+                threshold: newThreshold,
+            };
+            const validObjectSize = (0, objectSizeValidator_1.validateObjectSize)(items, getFuzzySearchMaxObjectSizeInBytes());
+            let result = null;
+            if (validObjectSize.valid) {
+                result = api.fuseSearch(items, options, searchPattern);
+                // reverse scores from fuse's 0 = perfect match to Cognigy's 1 = perfect match.
+                if (includeScore && result && Array.isArray(result) && result.length > 0) {
+                    result.forEach((item) => {
+                        if (item.score || item.score === 0) {
+                            item.score = 1 - item.score;
+                        }
+                    });
+                }
+            }
+            else {
+                result = {
+                    "error": `Source data file size limit (${getFuzzySearchMaxObjectSizeInBytes()} bytes) exceeded`
+                };
+            }
+            if (storeLocation === "context") {
+                api.addToContext(contextKey, result, "simple");
+            }
+            else {
+                api.addToInput(inputKey, result);
+            }
+        }
+        catch (error) {
+            if (storeLocation === "context") {
+                api.addToContext(contextKey, error, "simple");
+            }
+            else {
+                api.addToInput(inputKey, error);
+            }
+        }
+    }
+});
+//# sourceMappingURL=fuzzySearch.js.map

package/build/shared/charts/descriptors/nlu/index.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REGEX_SLOT_FILLER = exports.EXECUTE_COGNIGY_NLU = exports.ADD_LEXICON_KEYPHRASE = void 0;
+exports.FUZZY_SEARCH = exports.MATCH_PATTERN = exports.REGEX_SLOT_FILLER = exports.EXTRACT_ANSWER = exports.EXECUTE_COGNIGY_NLU = exports.ADD_LEXICON_KEYPHRASE = void 0;
 var addLexiconKeyphrase_1 = require("./addLexiconKeyphrase");
 Object.defineProperty(exports, "ADD_LEXICON_KEYPHRASE", { enumerable: true, get: function () { return addLexiconKeyphrase_1.ADD_LEXICON_KEYPHRASE; } });
 var executeCognigyNLU_1 = require("./executeCognigyNLU");
 Object.defineProperty(exports, "EXECUTE_COGNIGY_NLU", { enumerable: true, get: function () { return executeCognigyNLU_1.EXECUTE_COGNIGY_NLU; } });
+var extractAnswer_1 = require("./extractAnswer");
+Object.defineProperty(exports, "EXTRACT_ANSWER", { enumerable: true, get: function () { return extractAnswer_1.EXTRACT_ANSWER; } });
 var regexSlotFiller_1 = require("./regexSlotFiller");
 Object.defineProperty(exports, "REGEX_SLOT_FILLER", { enumerable: true, get: function () { return regexSlotFiller_1.REGEX_SLOT_FILLER; } });
+var matchPattern_1 = require("./matchPattern");
+Object.defineProperty(exports, "MATCH_PATTERN", { enumerable: true, get: function () { return matchPattern_1.MATCH_PATTERN; } });
+var fuzzySearch_1 = require("./fuzzySearch");
+Object.defineProperty(exports, "FUZZY_SEARCH", { enumerable: true, get: function () { return fuzzySearch_1.FUZZY_SEARCH; } });
 //# sourceMappingURL=index.js.map

package/build/shared/charts/descriptors/nlu/matchPattern.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MATCH_PATTERN = void 0;
+const createNodeDescriptor_1 = require("../../createNodeDescriptor");
+const patternMatcher_1 = require("./utils/patternMatcher");
+exports.MATCH_PATTERN = (0, createNodeDescriptor_1.createNodeDescriptor)({
+    type: "matchPattern",
+    defaultLabel: "Match Pattern",
+    preview: {
+        key: "patternGroupName",
+        type: "text"
+    },
+    summary: "Rule-based pattern matching for compound slot groups",
+    tags: ["nlu", "pattern", "patterns"],
+    fields: [
+        {
+            key: "patterns",
+            label: "Patterns",
+            type: "textArray",
+            description: "The patterns to match, e.g. 'from @city>origin to @city>destination'. Maximum: 20.",
+            defaultValue: ["@NUMBER>val1 or @NUMBER>val2"]
+        },
+        {
+            key: "patternGroupName",
+            label: "Pattern Group Name",
+            description: "Name for the slot compound group to be found under input.matchedPatterns.groupname",
+            type: "cognigyText",
+            defaultValue: "patternGroupName",
+            params: {
+                required: true
+            },
+        },
+        {
+            key: "alternateInput",
+            label: "Alternate Input",
+            description: "The input text to use instead of the current input text",
+            type: "cognigyText",
+        },
+        {
+            key: "detailedCompoundSlots",
+            label: "Detailed Match Results",
+            description: "Whether to store detailed results for the matched patterns or not",
+            type: "toggle",
+            defaultValue: false
+        },
+        {
+            key: "createNewSlots",
+            label: "Create New Slots",
+            description: "Whether to create new slots from tags or not",
+            type: "toggle",
+            defaultValue: false
+        },
+        {
+            key: "tagExistingSlots",
+            label: "Tag Existing Slots",
+            description: "Whether to tag existing slots or not",
+            type: "toggle",
+            defaultValue: true
+        },
+        {
+            key: "useFullSystemslotText",
+            label: "Replace system slots with full text",
+            description: "Match the full system slot text and use detailed values",
+            type: "toggle",
+            defaultValue: true,
+        }
+    ],
+    sections: [
+        {
+            key: "advanced",
+            label: "Advanced",
+            defaultCollapsed: true,
+            fields: [
+                "createNewSlots",
+                "tagExistingSlots",
+                "detailedCompoundSlots",
+                "useFullSystemslotText",
+                "alternateInput",
+            ]
+        }
+    ],
+    form: [
+        { type: "field", key: "patterns" },
+        { type: "field", key: "patternGroupName" },
+        { type: "section", key: "advanced" }
+    ],
+    function: async ({ cognigy, config }) => {
+        let { input, api } = cognigy;
+        const { patterns, patternGroupName, alternateInput, detailedCompoundSlots, createNewSlots, tagExistingSlots, useFullSystemslotText } = config;
+        if (!patterns || !Array.isArray(patterns) || patterns.length === 0) {
+            throw new Error("No patterns to match specified");
+        }
+        if (patterns.length > 20) {
+            throw new Error("Maximum of 20 patterns allowed");
+        }
+        // When using an alternative input, input.slots is empty - we need to call the cognigy nlu again to get the slots
+        let nluResult = {};
+        if (alternateInput) {
+            nluResult = await api.executeCognigyNLU(alternateInput, {}, input.inputId, {});
+        }
+        (0, patternMatcher_1.patternMatcher)({
+            input,
+            patterns,
+            patternGroupName,
+            detailedCompoundSlots,
+            tagExistingSlots,
+            createNewSlots,
+            useFullSystemslotText,
+            nluResult
+        });
+    }
+});
+//# sourceMappingURL=matchPattern.js.map

package/build/shared/charts/descriptors/nlu/regexSlotFiller.js

@@ -9,7 +9,7 @@ const createNodeDescriptor_1 = require("../../createNodeDescriptor");
  * Purpose:
  * Fills slots dynamically by evaluating a custom regular expression
  */
-exports.REGEX_SLOT_FILLER = createNodeDescriptor_1.createNodeDescriptor({
+exports.REGEX_SLOT_FILLER = (0, createNodeDescriptor_1.createNodeDescriptor)({
     type: "regexSlotFiller",
     defaultLabel: "Regex Slot Filler",
     summary: "Fills Slots dynamically by evaluating a custom regular expression",