@cognigy/rest-api-client 0.20.0 → 4.93.0

package/dist/esm/shared/charts/descriptors/nlu/generativeSlotFiller/generativeSlotFiller.js

@@ -0,0 +1,267 @@
+import { __awaiter } from "tslib";
+/* Custom modules */
+import { createNodeDescriptor } from "../../../createNodeDescriptor";
+import { createExtractionPrompt, createInvalidAnswerPrompt, createQuestionPrompt } from "./prompt";
+import logger from "../../../../helper/logger";
+import { SAY } from "../../message";
+export const GENERATIVE_SLOT_FILLER = createNodeDescriptor({
+    type: "generativeSlotFiller",
+    defaultLabel: "Generative Slot Filler",
+    summary: "UI__NODE_EDITOR__NLU__GENERATIVE_SLOT_FILLER__SUMMARY__DEFAULT",
+    dependencies: {
+        children: ["generativeSlotFillerFallback", "generativeSlotFillerSuccess"],
+    },
+    fields: [
+        {
+            key: "slotsConfig",
+            type: "json",
+            label: "UI__NODE_EDITOR__NLU__GENERATIVE_SLOT_FILLER__FIELDS__SLOT_CONFIG__DEFAULT_LABEL",
+        },
+        {
+            key: "amountOfLastUserInputs",
+            type: "slider",
+            label: "UI__NODE_EDITOR__NLU__GENERATIVE_SLOT_FILLER__FIELDS__AMOUNT_OF_LAST_USERS_INPUTS__LABEL",
+            params: {
+                min: 1,
+                max: 10,
+                step: 1,
+            },
+            defaultValue: 5
+        },
+        {
+            key: "maxQuestions",
+            label: "UI__NODE_EDITOR__NLU__GENERATIVE_MAX_QUESTIONS__DEFAULT_LABEL",
+            type: "slider",
+            defaultValue: 5,
+            params: {
+                min: 0,
+                max: 10,
+                step: 1
+            },
+        },
+        {
+            key: "temperature",
+            label: "UI__NODE_EDITOR__NLU__GENERATIVE_TEMPERATURE__DEFAULT_LABEL",
+            type: "slider",
+            description: "UI__NODE_EDITOR__NLU__GENERATIVE_SLIDER__DEFAULT_LABEL",
+            defaultValue: 1,
+            params: {
+                min: 0,
+                max: 1,
+                step: 0.1
+            },
+        },
+        {
+            key: "timeout",
+            label: "UI__NODE_EDITOR__NLU__GENERATIVE_TIMEOUT__DEFAULT_LABEL",
+            defaultValue: 6000,
+            type: "number",
+            description: "UI__NODE_EDITOR__NLU__GENERATIVE_TIMEOUT__DESCRIPTION",
+        },
+        {
+            key: "storeLocation",
+            type: "select",
+            label: "UI__NODE_EDITOR__NLU__GENERATIVE_STORE_LOCATION__DEFAULT_LABEL",
+            defaultValue: "context",
+            params: {
+                options: [
+                    {
+                        label: "UI__NODE_EDITOR__NLU__GENERATIVE_STORE_LOCATION__OPTIONS__INPUT__LABEL",
+                        value: "input"
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__NLU__GENERATIVE_STORE_LOCATION__OPTIONS__CONTEXT__LABEL",
+                        value: "context"
+                    }
+                ],
+                required: true
+            },
+        },
+        {
+            key: "inputKey",
+            type: "cognigyText",
+            label: "UI__NODE_EDITOR__NLU__GENERATIVE_INPUT_KEY__DEFAULT_LABEL",
+            defaultValue: "generativeSlotFiller",
+            condition: {
+                key: "storeLocation",
+                value: "input",
+            }
+        },
+        {
+            key: "contextKey",
+            type: "cognigyText",
+            label: "UI__NODE_EDITOR__NLU__GENERATIVE_CONTEXT_KEY__DEFAULT_LABEL",
+            defaultValue: "generativeSlotFiller",
+            condition: {
+                key: "storeLocation",
+                value: "context",
+            }
+        },
+    ],
+    sections: [
+        {
+            key: "advanced",
+            label: "UI__NODE_EDITOR__NLU__GENERATIVE_SLOT_FILLER__SECTIONS__ADVANCED__DEFAULT_LABEL",
+            defaultCollapsed: true,
+            fields: [
+                "temperature",
+                "timeout",
+            ]
+        },
+        {
+            key: "storage",
+            label: "UI__NODE_EDITOR__NLU__GENERATIVE_SLOT_FILLER__SECTIONS__STORAGE__DEFAULT_LABEL",
+            defaultCollapsed: true,
+            fields: [
+                "storeLocation",
+                "inputKey",
+                "contextKey",
+            ]
+        }
+    ],
+    form: [
+        { type: "field", key: "slotsConfig" },
+        { type: "field", key: "amountOfLastUserInputs" },
+        { type: "field", key: "maxQuestions" },
+        { type: "section", key: "advanced" },
+        { type: "section", key: "storage" },
+    ],
+    appearance: {},
+    tags: ["ai", "nlu"],
+    function: ({ cognigy, config, childConfigs, nodeId, organisationId }) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const { api, lastConversationEntries } = cognigy;
+        const { slotsConfig, amountOfLastUserInputs, maxQuestions, temperature, storeLocation, contextKey, inputKey, timeout, } = config;
+        const fallBackChild = childConfigs.find(child => child.type === "generativeSlotFillerFallback");
+        if ((slotsConfig === null || slotsConfig === void 0 ? void 0 : slotsConfig.length) < 1 || (lastConversationEntries === null || lastConversationEntries === void 0 ? void 0 : lastConversationEntries.length) < 1) {
+            api.setNextNode(fallBackChild.id);
+            return;
+        }
+        try {
+            // the filled slots that were found in the previous execution
+            const filledSlots = storeLocation === "context" ? cognigy.context[contextKey] : cognigy.input[inputKey];
+            const slots = [...slotsConfig];
+            if (filledSlots) {
+                for (const filledSlot of Object.keys(filledSlots)) {
+                    const slot = slots.find(slot => slot.tag === filledSlot);
+                    slot.value = filledSlots[filledSlot];
+                    // remove the validation, so that the slot is not validated again
+                    delete slot.validation;
+                }
+            }
+            const questionCountKey = `generativeSlotFiller_${nodeId}_questionCount`;
+            const questionCount = api.getSystemContext(questionCountKey) || 0;
+            // for questions, we only use the last user input
+            const extractionEntries = questionCount > 0 ? filterConversationEntries(lastConversationEntries, 1) : filterConversationEntries(lastConversationEntries, amountOfLastUserInputs);
+            const extractEntitiesprompt = createExtractionPrompt(slots, extractionEntries);
+            const data = {
+                prompt: extractEntitiesprompt,
+                temperature,
+                timeoutInMs: timeout,
+                useCase: "slotExtraction",
+            };
+            // TODO: Create a new useCase for this feature and use it here instead
+            const response = yield api.runGenerativeAIPrompt(data, "gptConversation");
+            const parsed = JSON.parse(response);
+            const slotsWithLexiconValidations = [];
+            slots.forEach(slot => {
+                if (parsed[slot.tag]) {
+                    if (slot.validation && slot.validation.type === "slot") {
+                        slotsWithLexiconValidations.push(slot);
+                    }
+                    slot.value = parsed[slot.tag];
+                }
+            });
+            for (const slot of slotsWithLexiconValidations) {
+                const nlu = yield api.executeCognigyNLU(parsed[slot.tag], null, "TODO", {
+                    parseIntents: false,
+                });
+                if ((_a = nlu === null || nlu === void 0 ? void 0 : nlu.slots) === null || _a === void 0 ? void 0 : _a[slot.validation.value]) {
+                    slot.invalid = false;
+                }
+                else {
+                    slot.invalid = true;
+                }
+            }
+            ;
+            let complete = true;
+            let allValid = true;
+            const missingSlots = [];
+            const invalidSlots = [];
+            const foundSlots = [];
+            for (const slot of slots) {
+                if (!slot.optional && !slot.value) {
+                    missingSlots.push(slot);
+                }
+                else if (slot.invalid) {
+                    invalidSlots.push(slot);
+                }
+                else if (slot.value && !slot.invalid) {
+                    foundSlots.push(slot);
+                }
+            }
+            const slotResult = {};
+            foundSlots.forEach(slot => {
+                slotResult[slot.tag] = slot.value;
+            });
+            if (storeLocation === "context") {
+                cognigy.context[contextKey] = slotResult;
+            }
+            else {
+                cognigy.input[contextKey] = slotResult;
+            }
+            if (missingSlots.length > 0) {
+                complete = false;
+            }
+            if (invalidSlots.length > 0) {
+                allValid = false;
+            }
+            if (complete && allValid) {
+                const childNode = childConfigs.find(child => child.type === "generativeSlotFillerSuccess");
+                api.setNextNode(childNode.id);
+                return;
+            }
+            if (questionCount >= maxQuestions && !(complete && allValid)) {
+                const childNode = childConfigs.find(child => child.type === "generativeSlotFillerFallback");
+                api.setNextNode(childNode.id);
+                return;
+            }
+            if (questionCount < maxQuestions && !(complete && allValid)) {
+                api.setSystemContext(questionCountKey, questionCount + 1);
+                const prompt = allValid ? createQuestionPrompt(foundSlots, missingSlots, extractionEntries) : createInvalidAnswerPrompt(invalidSlots, extractionEntries);
+                const data = {
+                    prompt,
+                    temperature,
+                    timeoutInMs: timeout,
+                    useCase: "slotExtractionQuestion",
+                };
+                // TODO: Create a new useCase for this feature and use it here instead
+                const question = yield api.runGenerativeAIPrompt(data, "gptConversation");
+                yield SAY.function({ cognigy, childConfigs: [], nodeId, organisationId, config: { say: { type: "text", text: [question] } } });
+                api.stopExecution();
+                api.setNextNode(nodeId);
+                return;
+            }
+        }
+        catch (error) {
+            api.setNextNode(fallBackChild.id);
+            logger.log("error", { traceId: cognigy.input.traceId }, `Error in generativeSlotFiller: ${error.message}`);
+        }
+    })
+});
+export const filterConversationEntries = (lastConversationEntries, amountOfLastUserInputs) => {
+    let addedUserInputsCount = 0;
+    let lastEntries = [];
+    // lastUserInputs is ordered newest -> oldest
+    for (const entry of lastConversationEntries) {
+        if (entry.source === "user" && addedUserInputsCount >= amountOfLastUserInputs) {
+            break;
+        }
+        lastEntries.push(entry);
+        if (entry.source === "user") {
+            addedUserInputsCount++;
+        }
+    }
+    return lastEntries;
+};
+//# sourceMappingURL=generativeSlotFiller.js.map

package/dist/esm/shared/charts/descriptors/nlu/generativeSlotFiller/generativeSlotFillerFallback.js

@@ -0,0 +1,24 @@
+/* Custom modules */
+import { createNodeDescriptor } from "../../../createNodeDescriptor";
+export const GENERATIVE_SLOT_FILLER_FALLBACK = createNodeDescriptor({
+    type: "generativeSlotFillerFallback",
+    parentType: "generativeSlotFillerFallback",
+    defaultLabel: "Fallback",
+    appearance: {
+        color: '#B3A7EA',
+        textColor: 'white',
+        contrastTextColor: 'black',
+        variant: 'mini'
+    },
+    constraints: {
+        editable: false,
+        deletable: false,
+        collapsable: true,
+        childFlowCreatable: true,
+        creatable: false,
+        movable: false,
+        placement: {},
+    },
+    tags: ["ai", "nlu"],
+});
+//# sourceMappingURL=generativeSlotFillerFallback.js.map

package/dist/esm/shared/charts/descriptors/nlu/generativeSlotFiller/generativeSlotFillerSuccess.js

@@ -0,0 +1,24 @@
+/* Custom modules */
+import { createNodeDescriptor } from "../../../createNodeDescriptor";
+export const GENERATIVE_SLOT_FILLER_SUCCESS = createNodeDescriptor({
+    type: "generativeSlotFillerSuccess",
+    parentType: "generativeSlotFillerSuccess",
+    defaultLabel: "Success",
+    appearance: {
+        color: '#B3A7EA',
+        textColor: 'white',
+        contrastTextColor: 'black',
+        variant: 'mini'
+    },
+    constraints: {
+        editable: false,
+        deletable: false,
+        collapsable: true,
+        childFlowCreatable: true,
+        creatable: false,
+        movable: false,
+        placement: {},
+    },
+    tags: ["ai", "nlu"],
+});
+//# sourceMappingURL=generativeSlotFillerSuccess.js.map

package/dist/esm/shared/charts/descriptors/nlu/generativeSlotFiller/prompt.js

@@ -0,0 +1,193 @@
+import { __awaiter } from "tslib";
+export const createExtractionPrompt = (slots, lastConversationEntries) => {
+    const userInput = lastConversationEntries.filter(entry => entry.source === "user").map(entry => "- " + entry.text).join("\n");
+    const conversation = createLastConverationString(lastConversationEntries);
+    let slotDescriptions = "";
+    let foundSlotDescriptions = "";
+    for (const slot of slots) {
+        if (!slot.value || slot.invalid) {
+            slotDescriptions += `- KEY: ${slot.tag}, DESCRIPTION: ${slot.optional ? "(if explicitly mentioned) " : ""}${slot.description}\n`;
+        }
+        else {
+            foundSlotDescriptions += `- KEY: ${slot.tag}, DESCRIPTION: ${slot.description}, FOUND: ${slot.value}\n`;
+        }
+    }
+    const prompt = `A USER has interacted with a BOT, this is the conversation so far:
+${conversation}
+${foundSlotDescriptions.length > 0 ? `\nSo far, the BOT has found the following entities:\n${foundSlotDescriptions}` : ""}
+Try to fill the following entities from the USER input, each entity has to match the given description field. If the value does not strictly match this description, leave the value empty:
+${slotDescriptions}
+Return the extracted entities as a valid JSON object, where the keys are the entity tags and the values are the extracted values.`;
+    return prompt;
+};
+export const createQuestionPrompt = (foundSlots, missingSlots, lastConversationEntries) => {
+    const conversation = createLastConverationString(lastConversationEntries);
+    const missingSlotDescriptions = missingSlots.map(slot => `- KEY: ${slot.tag}, DESCRIPTION: ${slot.description}`).join("\n");
+    const foundSlotDescriptions = foundSlots.map(slot => `- KEY: ${slot.tag}, DESCRIPTION: ${slot.description}, FOUND: ${slot.value}`).join("\n");
+    const prompt = `A user has interacted with a bot, this is the conversation so far:
+${conversation}
+
+${foundSlots.length > 0 ? `So far, the BOT has found the following entities:\n${foundSlotDescriptions}` : ""}
+
+The BOT wants to find the following entities:
+${missingSlotDescriptions}
+
+The BOT asks the user to for this information, based on the conversation so far. The BOT outputs should not be repetitive.
+BOT: `;
+    return prompt;
+};
+export const createInvalidAnswerPrompt = (invalidSlots, lastConversationEntries) => {
+    const userInput = createLastConverationString(lastConversationEntries);
+    const invalidSlotDescription = `- KEY: ${invalidSlots[0].tag}, DESCRIPTION: ${invalidSlots[0].description}, USER INPUT: ${invalidSlots[0].value}, INVALID BECAUSE: ${invalidSlots[0].validation.invalidReason}\n`;
+    const prompt = `A user has interacted with a bot, this is the conversation so far:
+${userInput}
+
+The USER has provided the following entities, but the USER INPUT was INVALID BECAUSE:
+${invalidSlotDescription}
+The BOT explains the answer why he can't use the answer and asks the USER again for this information, based on the conversation so far. The BOT does not give explicit alternatives.:
+BOT: `;
+    invalidSlots[0].invalid = false;
+    invalidSlots[0].value = "";
+    return prompt;
+};
+/* returns recentConversation as a multiline string:
+- BOT: Hello
+- USER: Hi
+*/
+export const createLastConverationString = (lastConversationEntries, turnLimit = 100) => {
+    const conversation = lastConversationEntries === null || lastConversationEntries === void 0 ? void 0 : lastConversationEntries.map(entry => "- " + (entry.source === "user" ? "USER: " : "BOT: ") + entry.text).slice(0, turnLimit).reverse().join("\n");
+    return conversation || "";
+};
+/* returns recentConversation as an openai formatted chat prompt, e.g.
+  [
+    {
+      "role": "system",
+      "content": "Imagine you're Michael and you're working in a agency for insurance sales for CNP Santander Insurance Europe. Your job is to call customers who have just gotten a loan from a bank. Your job is to sell them loan default insurance.\n\nIt's important you act tactfully and slowly approach the topic. Your main goal is to get the customer to confirm they want to the insurance, but don't be pushy.\n\nThe customer name is Vito Volpe. The loan amount for this customer is 10000 and the cost for the insurance is 0.89% of the loan amount per year, paid with the insurance payments. The customer can opt out at any time. \n\nOnce the customer is has confirmed they want the insurance, answer with \"SUCCESS\" only.\nIf the customer wants to reschedule the call, confirm the time and then answer with \"RESCHEDULE\" only.\n\nDon't immediately start with the offer. Make sure the customer is comfortable first.\n\nDon't discuss other insurance products. Don't negotiate on pricing.\n\nUse simple wording only. Speak in short sentences."
+    },
+    {
+      "role": "user",
+      "content": "Hello?"
+    },
+    {
+      "role": "assistant",
+      "content": "Good day, is this Mr. Vito Volpe I am speaking with?"
+    }
+  ]
+*/
+export const createLastConversationChatObject = (lastConversationEntries, systemMessage, turnLimit = 100, limitToOnlyUserMessages) => {
+    const conversation = [];
+    if (systemMessage) {
+        conversation.push({
+            role: "system",
+            content: systemMessage
+        });
+    }
+    if (limitToOnlyUserMessages) {
+        // limit the conversation entries to the last X messages with source user
+        lastConversationEntries === null || lastConversationEntries === void 0 ? void 0 : lastConversationEntries.filter(entry => entry.source === "user").slice(0, turnLimit).reverse().map(entry => {
+            var _a, _b;
+            if ((_b = (_a = entry === null || entry === void 0 ? void 0 : entry.text) === null || _a === void 0 ? void 0 : _a.trim()) === null || _b === void 0 ? void 0 : _b.length) {
+                conversation.push({
+                    role: "user",
+                    content: entry.text.trim()
+                });
+            }
+        });
+    }
+    else {
+        lastConversationEntries === null || lastConversationEntries === void 0 ? void 0 : lastConversationEntries.slice(0, turnLimit).reverse().map(entry => {
+            var _a, _b;
+            // if text exists, add to conversation
+            // necessary to prevent data only messages from being added
+            if ((_b = (_a = entry === null || entry === void 0 ? void 0 : entry.text) === null || _a === void 0 ? void 0 : _a.trim()) === null || _b === void 0 ? void 0 : _b.length) {
+                conversation.push({
+                    role: entry.source === "user" ? "user" : "assistant",
+                    content: entry.text.trim()
+                });
+            }
+        });
+    }
+    return conversation;
+};
+/* returns recentUserInput as a multiline string:
+- Hi
+- I want to order...
+*/
+export const createLastUserInputString = (lastConversationEntries, turnLimit = 100) => {
+    const userInput = lastConversationEntries.filter(entry => entry.source === "user").map(entry => "- " + entry.text).slice(0, turnLimit).reverse().join("\n");
+    return userInput || "";
+};
+/**
+ * Writes debug logs for LLM calls
+ * @param label the label of the log
+ * @param prompt the prompt used for the LLM call
+ * @param response the response of the LLM call
+ * @param debugLogTokenCount whether to log the token count
+ * @param debugLogRequestAndCompletion whether to log the request and completion
+ * @param cognigy the cognigy object (input, api, etc)
+ */
+export const writeLLMDebugLogs = (label, prompt, response, debugLogTokenCount, debugLogRequestAndCompletion, cognigy) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d;
+    const { api, input } = cognigy;
+    if (input.endpointType !== "adminconsole" && !api.getMetadata().isFollowSessionActive) {
+        // only return logs if in interaction panel or following session
+        return;
+    }
+    // stringify the response if it is an object
+    const responseOutputFormatted = typeof response === "object" ? JSON.stringify(response.result || response, null, 4) : response;
+    // debug logs are only processed for the interaction panel
+    if (debugLogRequestAndCompletion) {
+        try {
+            let requestTokenMessage = "";
+            let completionTokenMessage = "";
+            if (debugLogTokenCount) {
+                if (prompt) {
+                    const requestTokens = (_a = response === null || response === void 0 ? void 0 : response.tokenUsage) === null || _a === void 0 ? void 0 : _a.inputTokens;
+                    requestTokenMessage = ` (${requestTokens} Tokens)`;
+                }
+                if (response) {
+                    const completionTokens = (_b = response === null || response === void 0 ? void 0 : response.tokenUsage) === null || _b === void 0 ? void 0 : _b.outputTokens;
+                    completionTokenMessage = ` (${completionTokens} Tokens)`;
+                }
+            }
+            api.logDebugMessage(`UI__DEBUG_MODE__LLM_PROMPT__FULL_REQUEST__REQUEST${requestTokenMessage}:<br>${prompt}<br><br>UI__DEBUG_MODE__LLM_PROMPT__FULL_REQUEST__COMPLETION${completionTokenMessage}:<br>${responseOutputFormatted}`, "UI__DEBUG_MODE__LLM_PROMPT__FULL_REQUEST__HEADER");
+        }
+        catch (err) { }
+    }
+    else if (debugLogTokenCount) {
+        try {
+            let requestTokens = 0;
+            let completionTokens = 0;
+            requestTokens = (_c = response.tokenUsage) === null || _c === void 0 ? void 0 : _c.inputTokens;
+            completionTokens = (_d = response.tokenUsage) === null || _d === void 0 ? void 0 : _d.outputTokens;
+            const requestTokenMessage = requestTokens || "unknown";
+            const completionTokenMessage = completionTokens || "unknown";
+            const totalTokens = (requestTokens + completionTokens) || "unknown";
+            const completionMessage = response ? `<br>UI__DEBUG_MODE__LLM_PROMPT__TOKEN_COUNT__COMPLETION_TOKENS: ${completionTokenMessage}<br>UI__DEBUG_MODE__LLM_PROMPT__TOKEN_COUNT__TOTAL_TOKENS: ${totalTokens}` : "";
+            api.logDebugMessage(`UI__DEBUG_MODE__LLM_PROMPT__TOKEN_COUNT__REQUEST_TOKENS: ${requestTokenMessage}${completionMessage}`, "UI__DEBUG_MODE__LLM_PROMPT__TOKEN_COUNT__HEADER");
+        }
+        catch (err) { }
+    }
+});
+/**
+ * Converts an OpenAI chat object to a prompt string
+ * @param chat The OpenAI Chat Object
+ * @returns The concatenated string
+ */
+export const convertChatToPrompt = (chat) => {
+    let prompt = "";
+    for (const message of chat) {
+        if (message.role === "system") {
+            prompt += `${message.content}\n`;
+        }
+        else if (message.role === "user") {
+            prompt += `user: ${message.content}\n`;
+        }
+        else if (message.role === "assistant") {
+            prompt += `assistant: ${message.content}\n`;
+        }
+    }
+    prompt += "assistant: ";
+    return prompt;
+};
+//# sourceMappingURL=prompt.js.map

package/dist/esm/shared/charts/descriptors/nlu/index.js

@@ -0,0 +1,10 @@
+export { ADD_LEXICON_KEYPHRASE } from "./addLexiconKeyphrase";
+export { EXECUTE_COGNIGY_NLU } from "./executeCognigyNLU";
+export { REGEX_SLOT_FILLER } from "./regexSlotFiller";
+export { MATCH_PATTERN } from "./matchPattern";
+export { FUZZY_SEARCH } from "./fuzzySearch";
+export { GENERATIVE_SLOT_FILLER } from "./generativeSlotFiller/generativeSlotFiller";
+export { GENERATIVE_SLOT_FILLER_SUCCESS } from "./generativeSlotFiller/generativeSlotFillerSuccess";
+export { GENERATIVE_SLOT_FILLER_FALLBACK } from "./generativeSlotFiller/generativeSlotFillerFallback";
+export { CLEAN_TEXT } from "./cleanText";
+//# sourceMappingURL=index.js.map

package/dist/esm/shared/charts/descriptors/nlu/matchPattern.js

@@ -0,0 +1,111 @@
+import { __awaiter } from "tslib";
+import { createNodeDescriptor } from "../../createNodeDescriptor";
+import { patternMatcher } from "./utils/patternMatcher";
+export const MATCH_PATTERN = createNodeDescriptor({
+    type: "matchPattern",
+    defaultLabel: "Match Pattern",
+    preview: {
+        key: "patternGroupName",
+        type: "text"
+    },
+    summary: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__SUMMARY",
+    tags: ["ai", "nlu", "pattern", "patterns"],
+    fields: [
+        {
+            key: "patterns",
+            label: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__FIELDS__PATTERNS_LABEL",
+            type: "textArray",
+            description: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__FIELDS__PATTERNS_DESCRIPTION",
+            defaultValue: ["@NUMBER>val1 or @NUMBER>val2"]
+        },
+        {
+            key: "patternGroupName",
+            label: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__FIELDS__PATTERN_GROUP_NAME_LABEL",
+            description: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__FIELDS__PATTERN_GROUP_NAME_DESCRIPTION",
+            type: "cognigyText",
+            defaultValue: "patternGroupName",
+            params: {
+                required: true
+            },
+        },
+        {
+            key: "alternateInput",
+            label: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__FIELDS__ALTERNATE_INPUT_LABEL",
+            description: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__FIELDS__ALTERNATE_INPUT_DESCRIPTION",
+            type: "cognigyText",
+        },
+        {
+            key: "detailedCompoundSlots",
+            label: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__FIELDS__DETAILED_COMPOUND_SLOTS_LABEL",
+            description: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__FIELDS__DETAILED_COMPOUND_SLOTS_DESCRIPTION",
+            type: "toggle",
+            defaultValue: false
+        },
+        {
+            key: "createNewSlots",
+            label: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__FIELDS__CREATE_NEW_SLOTS_LABEL",
+            description: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__FIELDS__CREATE_NEW_SLOTS_DESCRIPTION",
+            type: "toggle",
+            defaultValue: false
+        },
+        {
+            key: "tagExistingSlots",
+            label: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__FIELDS__TAG_EXISTING_SLOTS_LABEL",
+            description: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__FIELDS__TAG_EXISTING_SLOTS_DESCRIPTION",
+            type: "toggle",
+            defaultValue: true
+        },
+        {
+            key: "useFullSystemslotText",
+            label: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__FIELDS__USE_FULL_SYSTEM_SLOT_TEXT_LABEL",
+            description: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__FIELDS__USE_FULL_SYSTEM_SLOT_TEXT_DESCRIPTION",
+            type: "toggle",
+            defaultValue: true,
+        }
+    ],
+    sections: [
+        {
+            key: "advanced",
+            label: "UI__NODE_EDITOR__NLU__MATCH_PATTERN__SECTIONS__ADVANCED__LABEL",
+            defaultCollapsed: true,
+            fields: [
+                "createNewSlots",
+                "tagExistingSlots",
+                "detailedCompoundSlots",
+                "useFullSystemslotText",
+                "alternateInput",
+            ]
+        }
+    ],
+    form: [
+        { type: "field", key: "patterns" },
+        { type: "field", key: "patternGroupName" },
+        { type: "section", key: "advanced" }
+    ],
+    function: ({ cognigy, config }) => __awaiter(void 0, void 0, void 0, function* () {
+        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 = yield api.executeCognigyNLU(alternateInput, {}, input.inputId, {});
+        }
+        patternMatcher({
+            input,
+            patterns,
+            patternGroupName,
+            detailedCompoundSlots,
+            tagExistingSlots,
+            createNewSlots,
+            useFullSystemslotText,
+            nluResult
+        });
+    })
+});
+//# sourceMappingURL=matchPattern.js.map

package/dist/esm/shared/charts/descriptors/nlu/regexSlotFiller.js

@@ -0,0 +1,44 @@
+import { __awaiter } from "tslib";
+/* Custom modules */
+import { createNodeDescriptor } from "../../createNodeDescriptor";
+/**
+ * Node name: 'regexSlotFiller'
+ *
+ * Purpose:
+ * Fills slots dynamically by evaluating a custom regular expression
+ */
+export const REGEX_SLOT_FILLER = createNodeDescriptor({
+    type: "regexSlotFiller",
+    defaultLabel: "Regex Slot Filler",
+    summary: "UI__NODE_EDITOR__NLU__REGEX_SLOT_FILLER__SUMMARY",
+    appearance: {
+        showIcon: false
+    },
+    fields: [
+        {
+            key: "regex",
+            type: "cognigyText",
+            label: "UI__NODE_EDITOR__NLU__REGEX_SLOT_FILLER__FIELDS__REGEX__LABEL",
+            description: "UI__NODE_EDITOR__NLU__REGEX_SLOT_FILLER__FIELDS__REGEX__DESCRIPTION",
+            defaultValue: ".*"
+        },
+        {
+            key: "flags",
+            type: "cognigyText",
+            label: "UI__NODE_EDITOR__NLU__REGEX_SLOT_FILLER__FIELDS__FLAGS__LABEL",
+            defaultValue: "gi"
+        },
+        {
+            key: "slot",
+            type: "cognigyText",
+            label: "UI__NODE_EDITOR__NLU__REGEX_SLOT_FILLER__FIELDS__SLOT__LABEL"
+        },
+    ],
+    tags: ["ai", "nlu", "regular", "expression", "slot"],
+    function: (regexSlotFillerParams) => __awaiter(void 0, void 0, void 0, function* () {
+        const { cognigy, config } = regexSlotFillerParams;
+        const { api } = cognigy;
+        api.setRegexSlot(regexSlotFillerParams);
+    })
+});
+//# sourceMappingURL=regexSlotFiller.js.map