@cognigy/rest-api-client 0.20.0 → 4.94.0

package/dist/esm/shared/charts/descriptors/logic/switch/switch.js

@@ -0,0 +1,228 @@
+import { __awaiter } from "tslib";
+/* Custom modules */
+import { createNodeDescriptor } from "../../../createNodeDescriptor";
+export const SWITCH = createNodeDescriptor({
+    type: "switch",
+    defaultLabel: "Lookup",
+    summary: "UI__NODE_EDITOR__SWITCH__SUMMARY",
+    appearance: {
+        color: "#FFC237",
+        textColor: "white",
+        contrastTextColor: "black",
+        variant: "hexagon",
+        showIcon: false,
+    },
+    constraints: {
+        collapsable: true,
+        placement: {
+            children: {
+                whitelist: ["case", "default"],
+            },
+        },
+    },
+    dependencies: {
+        children: ["default", "case", "case"],
+    },
+    fields: [
+        {
+            key: "switch",
+            type: "switchNode",
+            label: "UI__NODE_EDITOR__SWITCH__SWITCH__LABEL",
+            params: {
+                required: true,
+                options: [
+                    {
+                        label: "UI__NODE_EDITOR__SWITCH__SWITCH__INTENT__LABEL",
+                        value: "intent",
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__SWITCH__SWITCH__TEXT__LABEL",
+                        value: "text",
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__SWITCH__SWITCH__STATE__LABEL",
+                        value: "state",
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__SWITCH__SWITCH__TYPE__LABEL",
+                        value: "type",
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__SWITCH__SWITCH__MODE__LABEL",
+                        value: "mode",
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__SWITCH__SWITCH__HANDOVER_STATUS__LABEL",
+                        value: "handoverStatus",
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__SWITCH__SWITCH__CALL_EVENT_STATUS__LABEL",
+                        value: "callEventStatus",
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__SWITCH__SWITCH__COGNIGY_SCRIPT__LABEL",
+                        value: "cognigyScript",
+                    },
+                ],
+            },
+            defaultValue: {
+                type: "intent",
+                operator: "ci.intent"
+            },
+        },
+        {
+            key: "intentLevel",
+            type: "select",
+            label: "UI__NODE_EDITOR__SWITCH__INTENT_LEVEL__LABEL",
+            description: "UI__NODE_EDITOR__SWITCH__INTENT_LEVEL__DESCRIPTION",
+            condition: {
+                /** The key of the Field whose value should be matched */
+                key: "switch.type",
+                /** The expected value(s) that make this condition match */
+                value: "intent",
+            },
+            params: {
+                required: false,
+                options: [
+                    {
+                        label: "UI__NODE_EDITOR__SWITCH__INTENT_LEVEL__INPUT_INTENT__DEFAULT",
+                        value: "input.intent",
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__SWITCH__INTENT_LEVEL__INPUT_INTENT__LEVEL_1",
+                        value: "input.intentLevel.level1",
+                        groupName: "intentLevel"
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__SWITCH__INTENT_LEVEL__INPUT_INTENT__LEVEL_2",
+                        value: "input.intentLevel.level2",
+                        indentation: 1,
+                        groupName: "intentLevel"
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__SWITCH__INTENT_LEVEL__INPUT_INTENT__LEVEL_3",
+                        value: "input.intentLevel.level3",
+                        indentation: 2,
+                        groupName: "intentLevel"
+                    },
+                ],
+            },
+            defaultValue: "input.intent",
+        },
+        {
+            key: "useStrict",
+            label: "UI__NODE_EDITOR__SWITCH__USE_STRICT__LABEL",
+            type: "toggle",
+            description: "UI__NODE_EDITOR__SWITCH__USE_STRICT__DESCRIPTION"
+        }
+    ],
+    sections: [
+        {
+            key: "advanced",
+            label: "UI__NODE_EDITOR__SWITCH__ADVANCED__LABEL",
+            defaultCollapsed: true,
+            fields: [
+                "useStrict"
+            ]
+        },
+    ],
+    form: [
+        { type: "field", key: "switch" },
+        { type: "field", key: "intentLevel" },
+        { type: "section", key: "advanced" }
+    ],
+    preview: {
+        key: "switch.operator",
+        type: "custom",
+    },
+    tags: ["basic", "logic", "switch", "branch"],
+    function: ({ cognigy, config, childConfigs: children }) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const { api } = cognigy;
+        const { switch: { type }, useStrict, intentLevel, } = config;
+        let { switch: { operator }, } = config;
+        switch (type) {
+            case "intent":
+                operator = intentLevel || "input.intent";
+                break;
+            case "state":
+                operator = "input.state";
+                break;
+            case "type":
+                operator = "input.type";
+                break;
+            case "mode":
+                operator = "input.mode";
+                break;
+            case "text":
+                operator = "input.text";
+                break;
+            case "handoverStatus":
+                operator = "input.handover.status";
+                break;
+            case "callEventStatus":
+                operator = "input.data.event";
+                break;
+            case "cognigyScript":
+            default:
+                operator = operator;
+                break;
+        }
+        let parsedOperator;
+        if (
+        /**
+         * Check if {{CognigyScript}} or token in the operator was already parsed in executeNode.
+         * If that is the case, we don't parse again.
+         * Otherwise parseCognigyScriptText(`{{${operator}}}`) would log an error.
+         */
+        config.switch.operator !== config.switch.originalOperator &&
+            (config.switch.originalOperator.startsWith("[[snippet-") ||
+                (config.switch.originalOperator.startsWith("{{") && config.switch.originalOperator.endsWith("}}")))) {
+            parsedOperator = operator;
+        }
+        else {
+            /**
+             * Try to parse the direct CognigyScript
+             * in the operator field. In case the user
+             * has used {{}} markers in the operator field
+             * by mistake, then CS has already been parsed,
+             * causing the parser return empty string.
+             */
+            parsedOperator = (_a = api.parseCognigyScriptText(`{{${operator}}}`)) !== null && _a !== void 0 ? _a : operator;
+            if (parsedOperator === "") {
+                parsedOperator = operator;
+            }
+        }
+        const matchedCase = children === null || children === void 0 ? void 0 : children.find((child) => {
+            var _a, _b;
+            if (child.type !== "case") {
+                return;
+            }
+            if (useStrict) {
+                return api.parseCognigyScriptText(`${(_a = child.config.case.value) === null || _a === void 0 ? void 0 : _a.trim()}`) === parsedOperator;
+            }
+            else {
+                /**
+                 * We cast the case
+                 * and the operator to strings to avoid issues
+                 * where e.g. the case contains a string but the
+                 * operator is a number. We do not support switching on
+                 * objects
+                 */
+                const parsedCognigyScriptText = `${api.parseCognigyScriptText(`${(_b = child.config.case.value) === null || _b === void 0 ? void 0 : _b.trim()}`)}`;
+                const parsedOperatorString = `${parsedOperator}`;
+                return parsedCognigyScriptText === parsedOperatorString;
+            }
+        });
+        if (matchedCase) {
+            api.setNextNode(matchedCase.id);
+            return;
+        }
+        const defaultCase = children === null || children === void 0 ? void 0 : children.find((child) => child.type === "default");
+        if (defaultCase) {
+            api.setNextNode(defaultCase.id);
+            return;
+        }
+    }),
+});
+//# sourceMappingURL=switch.js.map

package/dist/esm/shared/charts/descriptors/logic/switchLocale.js

@@ -0,0 +1,63 @@
+import { __awaiter } from "tslib";
+/* Custom modules */
+import { createNodeDescriptor } from "../../createNodeDescriptor";
+/**
+ * Node name: 'switchLocale'
+ *
+ * Purpose:
+ * Switches the session into another Locale
+ */
+export const SWITCH_LOCALE = createNodeDescriptor({
+    type: "switchLocale",
+    defaultLabel: "Switch Locale",
+    summary: "UI__NODE_EDITOR__SWITCH_LOCALE__SUMMARY",
+    appearance: {
+        showIcon: false
+    },
+    fields: [
+        {
+            key: "getLocaleFromScript",
+            type: "toggle",
+            label: "UI__NODE_EDITOR__SWITCH_LOCALE__GET_LOCALE_FROM_SCRIPT__LABEL",
+            defaultValue: false
+        },
+        {
+            key: "localeReferenceId",
+            type: "localeField",
+            label: "UI__NODE_EDITOR__SWITCH_LOCALE__LOCALE_REFERENCE_ID__LABEL",
+            condition: {
+                key: "getLocaleFromScript",
+                value: false
+            },
+            params: {
+                required: true
+            }
+        },
+        {
+            key: "localeScript",
+            type: "cognigyText",
+            label: "UI__NODE_EDITOR__SWITCH_LOCALE__LOCALE_SCRIPT__LABEL",
+            description: "UI__NODE_EDITOR__SWITCH_LOCALE__LOCALE_SCRIPT__DESCRIPTION",
+            condition: {
+                key: "getLocaleFromScript",
+                value: true
+            },
+            params: {
+                required: true
+            }
+        }
+    ],
+    tags: ["logic", "locale", "language"],
+    function: ({ cognigy, config }) => __awaiter(void 0, void 0, void 0, function* () {
+        const { localeReferenceId, localeScript, getLocaleFromScript } = config;
+        const { api } = cognigy;
+        if (getLocaleFromScript) {
+            yield api.setLocaleReferenceId(localeScript);
+        }
+        else {
+            yield api.setLocaleReferenceId(localeReferenceId);
+        }
+        api.logDebugMessage(`UI__DEBUG_MODE__SWITCH_LOCALE__MESSAGE`);
+    })
+});
+//# sourceMappingURL=switchLocale.js.map

package/dist/esm/shared/charts/descriptors/logic/think.js

@@ -0,0 +1,108 @@
+import { __awaiter } from "tslib";
+/* Custom modules */
+import { createNodeDescriptor } from "../../createNodeDescriptor";
+import { logFullConfigToDebugMode } from "../../../helper/logFullConfigToDebugMode";
+/**
+ * Node name: 'think'
+ *
+ * Purpose:
+ * Thinks a message into the Flow
+ */
+export const THINK = createNodeDescriptor({
+    type: "think",
+    defaultLabel: "Think Legacy",
+    summary: "UI__NODE_EDITOR__THINK__SUMMARY",
+    appearance: {
+        showIcon: false,
+    },
+    constraints: {
+        placement: {},
+        creatable: false,
+    },
+    fields: [
+        {
+            key: "thinkType",
+            type: "select",
+            label: "UI__NODE_EDITOR__THINK__THINK_TYPE__LABEL",
+            description: "UI__NODE_EDITOR__THINK__THINK_TYPE__DESCRIPTION",
+            params: {
+                options: [
+                    {
+                        label: "UI__NODE_EDITOR__THINK__THINK_TYPE__DEFAULT__LABEL",
+                        value: "default",
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__THINK__THINK_TYPE__INTENT__LABEL",
+                        value: "intent",
+                    },
+                ],
+            },
+            defaultValue: "default"
+        },
+        {
+            key: "text",
+            type: "cognigyText",
+            label: "UI__NODE_EDITOR__THINK__TEXT__LABEL",
+            description: "UI__NODE_EDITOR__THINK__TEXT__DESCRIPTION",
+            condition: {
+                key: "thinkType",
+                value: "intent",
+                negate: true
+            }
+        },
+        {
+            key: "data",
+            type: "json",
+            label: "UI__NODE_EDITOR__THINK__DATA__LABEL",
+            defaultValue: "{}",
+            condition: {
+                key: "thinkType",
+                value: "intent",
+                negate: true
+            }
+        },
+        {
+            key: "intent",
+            type: "cognigyText",
+            label: "UI__NODE_EDITOR__THINK__INTENT__LABEL",
+            description: "UI__NODE_EDITOR__THINK__INTENT__DESCRIPTION",
+            condition: {
+                key: "thinkType",
+                value: "intent"
+            }
+        },
+    ],
+    sections: [
+        {
+            key: "advanced",
+            label: "UI__NODE_EDITOR__THINK__ADVANCED__LABEL",
+            defaultCollapsed: true,
+            fields: [
+                "thinkType",
+                "data"
+            ]
+        }
+    ],
+    form: [
+        { type: "field", key: "text" },
+        { type: "field", key: "intent" },
+        { type: "section", key: "advanced" },
+    ],
+    preview: {
+        key: "text",
+        type: "text",
+    },
+    tags: ["logic", "recursion", "inject"],
+    function: ({ cognigy, config }) => __awaiter(void 0, void 0, void 0, function* () {
+        const { text, data, intent, thinkType, } = config;
+        const { api } = cognigy;
+        logFullConfigToDebugMode(cognigy, config);
+        if (thinkType === "intent") {
+            api.think(`cIntent:${intent}`, null);
+        }
+        else if (text || data) {
+            api.think(text, data);
+        }
+    })
+});
+//# sourceMappingURL=think.js.map

package/dist/esm/shared/charts/descriptors/logic/thinkV2.js

@@ -0,0 +1,211 @@
+import { __awaiter } from "tslib";
+/* Custom modules */
+import { createNodeDescriptor } from "../../createNodeDescriptor";
+import { GO_TO } from "../logic";
+import { logFullConfigToDebugMode } from "../../../helper/logFullConfigToDebugMode";
+import { InternalServerError } from "../../../errors";
+/**
+ * Node name: 'think'
+ *
+ * Purpose:
+ * Thinks a message into the Flow
+ */
+export const THINK_V2 = createNodeDescriptor({
+    type: "thinkV2",
+    defaultLabel: "Think",
+    summary: "UI__NODE_EDITOR__THINK_V2__SUMMARY",
+    appearance: {
+        showIcon: false
+    },
+    fields: [
+        {
+            key: "thinkType",
+            type: "select",
+            label: "UI__NODE_EDITOR__THINK_V2__THINK_TYPE__LABEL",
+            description: "UI__NODE_EDITOR__THINK_V2__THINK_TYPE__DESCRIPTION",
+            params: {
+                options: [
+                    {
+                        label: "UI__NODE_EDITOR__THINK_V2__THINK_TYPE__DEFAULT__LABEL",
+                        value: "default",
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__THINK_V2__THINK_TYPE__INTENT__LABEL",
+                        value: "intent",
+                    },
+                ],
+            },
+            defaultValue: "default"
+        },
+        {
+            key: "text",
+            type: "cognigyText",
+            label: "UI__NODE_EDITOR__THINK_V2__TEXT__LABEL",
+            description: "UI__NODE_EDITOR__THINK_V2__TEXT__DESCRIPTION",
+            condition: {
+                key: "thinkType",
+                value: "intent",
+                negate: true
+            }
+        },
+        {
+            key: "data",
+            type: "json",
+            label: "UI__NODE_EDITOR__THINK_V2__DATA__LABEL",
+            defaultValue: "{}",
+            condition: {
+                key: "thinkType",
+                value: "intent",
+                negate: true
+            }
+        },
+        {
+            key: "intent",
+            type: "cognigyText",
+            label: "UI__NODE_EDITOR__THINK_V2__INTENT__LABEL",
+            description: "UI__NODE_EDITOR__THINK_V2__INTENT__DESCRIPTION",
+            condition: {
+                key: "thinkType",
+                value: "intent"
+            }
+        },
+        {
+            key: "logErrorToSystem",
+            label: "UI__NODE_EDITOR__THINK_V2__LOG_ERROR_TO_SYSTEM__LABEL",
+            description: "UI__NODE_EDITOR__THINK_V2__LOG_ERROR_TO_SYSTEM__DESCRIPTION",
+            type: "toggle",
+            defaultValue: false,
+        },
+        {
+            key: "errorHandling",
+            type: "select",
+            label: "UI__NODE_EDITOR__THINK_V2__HANDLE_ERROR__LABEL",
+            description: "UI__NODE_EDITOR__THINK_V2__HANDLE_ERROR__DESCRIPTION",
+            defaultValue: "continue",
+            params: {
+                options: [
+                    {
+                        label: "UI__NODE_EDITOR__THINK_V2__HANDLE_ERROR__OPTIONS__STOP__LABEL",
+                        value: "stop"
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__THINK_V2__HANDLE_ERROR__OPTIONS__CONTINUE__LABEL",
+                        value: "continue"
+                    },
+                    {
+                        label: "UI__NODE_EDITOR__THINK_V2__HANDLE_ERROR__ERROR__OPTIONS__GOTO__LABEL",
+                        value: "goto"
+                    },
+                ]
+            }
+        },
+        {
+            key: "errorMessage",
+            label: "UI__NODE_EDITOR__THINK_V2__ERROR_MESSAGE__LABEL",
+            type: "cognigyText",
+            description: "UI__NODE_EDITOR__THINK_V2__ERROR_MESSAGE__DESCRIPTION",
+            defaultValue: "",
+            condition: {
+                key: "errorHandling",
+                value: "continue"
+            }
+        },
+        {
+            key: "errorHandlingGotoTarget",
+            type: "flowNode",
+            label: "UI__NODE_EDITOR__THINK_V2__ERROR__GOTO_NODE__LABEL",
+            condition: {
+                key: "errorHandling",
+                value: "goto"
+            }
+        },
+    ],
+    sections: [
+        {
+            key: "advanced",
+            label: "UI__NODE_EDITOR__THINK_V2__ADVANCED__LABEL",
+            defaultCollapsed: true,
+            fields: [
+                "thinkType",
+                "data"
+            ]
+        },
+        {
+            key: "errors",
+            label: "UI__NODE_EDITOR__THINK_V2__SECTIONS__ERRORS__LABEL",
+            defaultCollapsed: true,
+            fields: [
+                "logErrorToSystem",
+                "errorHandling",
+                "errorMessage",
+                "errorHandlingGotoTarget",
+            ]
+        }
+    ],
+    form: [
+        { type: "field", key: "text" },
+        { type: "field", key: "intent" },
+        { type: "section", key: "advanced" },
+        { type: "section", key: "errors" },
+    ],
+    preview: {
+        key: "text",
+        type: "text",
+    },
+    tags: ["basic", "logic", "recursion", "inject"],
+    function: ({ cognigy, config, nodeId }) => __awaiter(void 0, void 0, void 0, function* () {
+        const { text, data, intent, thinkType, errorHandling = "continue", errorHandlingGotoTarget, errorMessage, logErrorToSystem, } = config;
+        const { api, input } = cognigy;
+        const { traceId } = input;
+        logFullConfigToDebugMode(cognigy, config);
+        if ((thinkType === "default" && typeof text !== "string")
+            || (thinkType === "intent" && typeof intent !== "string")) {
+            const errorDetails = {
+                message: "Think input should be string",
+                originalInput: JSON.stringify(text || intent)
+            };
+            if (logErrorToSystem) {
+                api.log("error", JSON.stringify(errorDetails));
+            }
+            api.logDebugError(errorDetails, "UI__DEBUG_MODE__THINK_NODE__ERROR");
+            // handle error depending on the settings
+            if (errorHandling === "continue") {
+                // output the provided error message
+                if (errorMessage) {
+                    yield api.output(errorMessage, null);
+                }
+            }
+            else if (errorHandling === "goto") {
+                if (!errorHandlingGotoTarget) {
+                    throw new Error("GoTo Target is required");
+                }
+                const gotoParams = {
+                    cognigy,
+                    childConfigs: [],
+                    nodeId,
+                    config: {
+                        flowNode: {
+                            flow: errorHandlingGotoTarget.flow,
+                            node: errorHandlingGotoTarget.node,
+                        },
+                        injectedText: undefined,
+                        injectedData: undefined,
+                        executionMode: "continue",
+                        absorbContext: false
+                    }
+                };
+                yield GO_TO.function(gotoParams);
+            }
+            else {
+                throw new InternalServerError(errorDetails.message, { traceId });
+            }
+        }
+        else if (thinkType === "intent") {
+            api.thinkV2(`cIntent:${intent}`, null);
+        }
+        else if (text || data) {
+            api.thinkV2(text, data);
+        }
+    })
+});
+//# sourceMappingURL=thinkV2.js.map

package/dist/esm/shared/charts/descriptors/logic/wait.js

@@ -0,0 +1,29 @@
+import { __awaiter } from "tslib";
+/* Custom modules */
+import { createNodeDescriptor } from "../../createNodeDescriptor";
+export const WAIT = createNodeDescriptor({
+    type: "wait",
+    defaultLabel: "Wait for Input",
+    summary: "UI__NODE_EDITOR__WAIT__SUMMARY",
+    behavior: {
+        stopping: false,
+    },
+    appearance: {
+        showIcon: false,
+        color: "#ec7372",
+        textColor: "#ffffff",
+        contrastTextColor: "black",
+        variant: "mini"
+    },
+    constraints: {
+        editable: false,
+        placement: {}
+    },
+    tags: ["basic", "logic"],
+    function: ({ cognigy, nodeId }) => __awaiter(void 0, void 0, void 0, function* () {
+        const { api } = cognigy;
+        api.stopExecution();
+        return;
+    })
+});
+//# sourceMappingURL=wait.js.map