@cognigy/rest-api-client 0.19.0 → 4.93.0

package/dist/esm/connector/AxiosAdapter.js

@@ -0,0 +1,191 @@
+import { __awaiter } from "tslib";
+/* Node Modules */
+import Axios from "axios";
+/* Custom Modules */
+import { ErrorCode, ErrorCollection, NetworkError } from "../shared/errors";
+import { HttpStatusCode } from "../shared/helper/HttpStatusCode";
+import { OAuth2Errors } from "../authentication/OAuth2/IOAuth2ErrorResponse";
+import { isRetryAllowed } from "./isRetryAllowed";
+import { isRetryableStatus } from "./isRetryableStatus";
+import { exponentialDelay } from "./exponentialDelay";
+import { retryAfterDelay } from "./retryAfterDelay";
+export class AxiosAdapter {
+    constructor(config) {
+        this.config = config;
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    request(request, client) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { maxRetries = (_b = (_a = this.config.maxRetries) !== null && _a !== void 0 ? _a : client.config.maxRetries) !== null && _b !== void 0 ? _b : 3, retryCondition = AxiosAdapter.isNetworkOrIdempotentRequestError, retryDelay = exponentialDelay, shouldResetTimeout = false } = request;
+            if (request.withAuthentication) {
+                const authenticationHeaders = yield ((_c = client.authenticationHandler) === null || _c === void 0 ? void 0 : _c.getAuthenticationHeaders());
+                request.headers = Object.assign(Object.assign({}, request.headers), authenticationHeaders);
+            }
+            const axiosRequest = yield this.convertRequest(request, client);
+            request.lastRequestTime = Date.now();
+            request.retryCount = request.retryCount || 0;
+            if (request.retryCount === maxRetries) {
+                axiosRequest.validateStatus = null;
+            }
+            let axiosResponse;
+            try {
+                axiosResponse = yield Axios(axiosRequest);
+            }
+            catch (error) {
+                if (isAxiosError(error)) {
+                    const shouldRetry = retryCondition(error) && request.retryCount < maxRetries;
+                    if (shouldRetry) {
+                        request.retryCount += 1;
+                        const delay = retryAfterDelay((_d = error.response) === null || _d === void 0 ? void 0 : _d.headers, request.lastRequestTime) || retryDelay(request.retryCount, error);
+                        if (!shouldResetTimeout &&
+                            request.timeout &&
+                            request.lastRequestTime) {
+                            const lastRequestDuration = Date.now() - request.lastRequestTime;
+                            request.timeout = Math.max(request.timeout - lastRequestDuration - delay, 1);
+                        }
+                        const requestPromise = new Promise((resolve) => setTimeout(() => resolve(this.request(request, client)), delay));
+                        const response = yield requestPromise;
+                        return response;
+                    }
+                }
+                this.handleError(error);
+            }
+            if (isAxiosError(axiosResponse) || axiosResponse.status >= 400) {
+                this.handleError(axiosResponse);
+            }
+            const response = yield this.convertResponse(axiosResponse);
+            return response;
+        });
+    }
+    get(request, client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(Object.assign(Object.assign({}, request), { method: "GET" }), client);
+        });
+    }
+    post(request, client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(Object.assign(Object.assign({}, request), { method: "POST" }), client);
+        });
+    }
+    patch(request, client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(Object.assign(Object.assign({}, request), { method: "PATCH" }), client);
+        });
+    }
+    put(request, client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(Object.assign(Object.assign({}, request), { method: "PUT" }), client);
+        });
+    }
+    head(request, client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(Object.assign(Object.assign({}, request), { method: "HEAD" }), client);
+        });
+    }
+    convertRequest(request, client) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const baseUrl = (_a = request.baseUrl) !== null && _a !== void 0 ? _a : this.config.baseUrl;
+            const axiosRequest = {
+                data: request.data,
+                headers: request.headers,
+                method: request.method || "GET",
+                url: `${baseUrl}${request.url}`,
+                validateStatus: (status) => !isRetryableStatus(status)
+            };
+            if (typeof request.onProgress === "function") {
+                axiosRequest.onDownloadProgress = (progressEvent) => {
+                    const { loaded, total } = progressEvent;
+                    return request.onProgress({ loaded, total });
+                };
+                axiosRequest.onUploadProgress = (progressEvent) => {
+                    const { loaded, total } = progressEvent;
+                    return request.onProgress({ loaded, total });
+                };
+            }
+            return axiosRequest;
+        });
+    }
+    handleError(axiosResponse) {
+        var _a, _b, _c, _d;
+        if (isAxiosError(axiosResponse)) {
+            if (AxiosAdapter.isNetworkError(axiosResponse)) {
+                throw new NetworkError("Request failed. Please check your Network Connection or Firewall Settings.", null, axiosResponse, axiosResponse);
+            }
+            else {
+                const data = ((_a = axiosResponse.response) === null || _a === void 0 ? void 0 : _a.data) || {
+                    code: 500,
+                    detail: "An unexpected error occurred. Please try again later.",
+                    details: {},
+                    traceId: "aixos-error-trace-id"
+                };
+                const errorClass = ErrorCollection[data.code] ||
+                    ErrorCollection[ErrorCode.INTERNAL_SERVER_ERROR];
+                throw new errorClass(data.detail, { traceId: data.traceId }, undefined, data.details);
+            }
+        }
+        if (isAxiosResponse(axiosResponse)) {
+            const errorClass = ErrorCollection[(_b = axiosResponse.data) === null || _b === void 0 ? void 0 : _b.code] ||
+                ErrorCollection[axiosResponse.status] ||
+                ErrorCollection[ErrorCode.INTERNAL_SERVER_ERROR];
+            if ((axiosResponse.status === HttpStatusCode.UNAUTHORIZED ||
+                errorClass === ErrorCollection[ErrorCode.UNAUTHORIZED_ERROR] ||
+                OAuth2Errors.includes((_c = axiosResponse.data) === null || _c === void 0 ? void 0 : _c.error)) &&
+                typeof this.config.onUnauthorized === "function") {
+                this.config.onUnauthorized();
+            }
+            if (OAuth2Errors.includes((_d = axiosResponse.data) === null || _d === void 0 ? void 0 : _d.error)) {
+                throw new errorClass(axiosResponse.data.detail, { traceId: axiosResponse.data.traceId }, undefined, axiosResponse.data);
+            }
+            throw new errorClass(axiosResponse.data.detail, { traceId: axiosResponse.data.traceId }, undefined, axiosResponse.data.details);
+        }
+    }
+    convertResponse(axiosResponse) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = {
+                data: axiosResponse.data,
+                headers: axiosResponse.headers,
+                status: axiosResponse.status,
+                statusText: axiosResponse.statusText
+            };
+            return response;
+        });
+    }
+    static isNetworkError(error) {
+        return (
+        // https://github.com/softonic/axios-retry/issues/138
+        (error.isAxiosError && error.message === "Network Error") ||
+            (!error.response &&
+                Boolean(error.code) && // Prevents retrying cancelled requests
+                error.code !== "ECONNABORTED" && // Prevents retrying timed out requests
+                isRetryAllowed(error.code)) // Prevents retrying unsafe errors
+        );
+    }
+    static isRetryableError(error) {
+        return (error.code !== "ECONNABORTED" &&
+            (!error.response || isRetryableStatus(error.response.status)));
+    }
+    static isIdempotentRequestError(error) {
+        if (!error.config) {
+            // Cannot determine if the request can be retried
+            return false;
+        }
+        return (AxiosAdapter.isRetryableError(error) &&
+            ["get", "head", "options", "put", "delete"].indexOf(error.config.method.toLowerCase()) !== -1);
+    }
+    static isNetworkOrIdempotentRequestError(error) {
+        return (AxiosAdapter.isNetworkError(error) ||
+            AxiosAdapter.isIdempotentRequestError(error));
+    }
+}
+export function isAxiosError(error) {
+    return (error === null || error === void 0 ? void 0 : error.isAxiosError) === true;
+}
+export function isAxiosResponse(error) {
+    return ((error === null || error === void 0 ? void 0 : error.isAxiosError) === undefined ||
+        (error === null || error === void 0 ? void 0 : error.isAxiosError) === false);
+}
+//# sourceMappingURL=AxiosAdapter.js.map

package/dist/esm/connector/IHttpAdapter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IHttpAdapter.js.map

package/dist/esm/connector/IHttpProgressEvent.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IHttpProgressEvent.js.map

package/dist/esm/connector/IHttpRequest.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IHttpRequest.js.map

package/dist/esm/connector/IHttpResponse.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IHttpResponse.js.map

package/dist/esm/connector/THttpLib.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=THttpLib.js.map

package/dist/esm/connector/TMethod.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TMethod.js.map

package/dist/esm/connector/exponentialDelay.js

@@ -0,0 +1,18 @@
+/**
+ * Exponential backoff is the process of a client periodically retrying a
+ * failed request over an increasing amount of time. It is a standard error
+ * handling strategy for network applications. The Core Reporting API is
+ * designed with the expectation that clients which choose to retry failed
+ * requests do so using exponential backoff. Besides being "required", using
+ * exponential backoff increases the efficiency of bandwidth usage, reduces
+ * the number of requests required to get a successful response, and
+ * maximizes the throughput of requests in concurrent environments.
+ *
+ * @see https://developers.google.com/analytics/devguides/reporting/core/v3/errors#backoff
+ */
+export function exponentialDelay(retryNumber = 0) {
+    const delayInSeconds = Math.pow(2, retryNumber) * 1000;
+    const randomMs = ~~(1000 * Math.random());
+    return delayInSeconds + randomMs;
+}
+//# sourceMappingURL=exponentialDelay.js.map

package/dist/esm/connector/index.js

@@ -0,0 +1,6 @@
+export { AxiosAdapter } from "./AxiosAdapter";
+export { exponentialDelay } from "./exponentialDelay";
+export { isRetryAllowed } from "./isRetryAllowed";
+export { isRetryableStatus } from "./isRetryableStatus";
+export { retryAfterDelay } from "./retryAfterDelay";
+//# sourceMappingURL=index.js.map

package/dist/esm/connector/isRetryAllowed.js

@@ -0,0 +1,55 @@
+const allowList = [
+    "ETIMEDOUT",
+    "ECONNRESET",
+    "ENETUNREACH",
+    "EADDRINUSE",
+    "ESOCKETTIMEDOUT",
+    "ECONNREFUSED",
+    "EPIPE",
+    "EHOSTUNREACH",
+    "EAI_AGAIN"
+];
+const denyList = [
+    "ENOTFOUND",
+    // SSL errors from https://github.com/nodejs/node/blob/e585caa2bebbd238c763af588a40879b61cf240f/src/node_crypto.cc#L2563-L2589
+    "UNABLE_TO_GET_ISSUER_CERT",
+    "UNABLE_TO_GET_CRL",
+    "UNABLE_TO_DECRYPT_CERT_SIGNATURE",
+    "UNABLE_TO_DECRYPT_CRL_SIGNATURE",
+    "UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY",
+    "CERT_SIGNATURE_FAILURE",
+    "CRL_SIGNATURE_FAILURE",
+    "CERT_NOT_YET_VALID",
+    "CERT_HAS_EXPIRED",
+    "CRL_NOT_YET_VALID",
+    "CRL_HAS_EXPIRED",
+    "ERROR_IN_CERT_NOT_BEFORE_FIELD",
+    "ERROR_IN_CERT_NOT_AFTER_FIELD",
+    "ERROR_IN_CRL_LAST_UPDATE_FIELD",
+    "ERROR_IN_CRL_NEXT_UPDATE_FIELD",
+    "OUT_OF_MEM",
+    "DEPTH_ZERO_SELF_SIGNED_CERT",
+    "SELF_SIGNED_CERT_IN_CHAIN",
+    "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+    "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+    "CERT_CHAIN_TOO_LONG",
+    "CERT_REVOKED",
+    "INVALID_CA",
+    "PATH_LENGTH_EXCEEDED",
+    "INVALID_PURPOSE",
+    "CERT_UNTRUSTED",
+    "CERT_REJECTED"
+];
+export function isRetryAllowed(errorCode) {
+    if (!errorCode) {
+        return true;
+    }
+    if (allowList.includes(errorCode)) {
+        return true;
+    }
+    if (denyList.includes(errorCode)) {
+        return false;
+    }
+    return true;
+}
+//# sourceMappingURL=isRetryAllowed.js.map

package/dist/esm/connector/isRetryableStatus.js

@@ -0,0 +1,10 @@
+/* Custom Modules */
+import { HttpStatusCode } from "../shared/helper/HttpStatusCode";
+export function isRetryableStatus(status) {
+    return (status === HttpStatusCode.REQUEST_TIMEOUT ||
+        status === HttpStatusCode.TOO_MANY_REQUESTS ||
+        (status >= 500 &&
+            status <= 599 &&
+            status !== HttpStatusCode.NETWORK_AUTHENTICATION_REQUIRED));
+}
+//# sourceMappingURL=isRetryableStatus.js.map

package/dist/esm/connector/retryAfterDelay.js

@@ -0,0 +1,30 @@
+/**
+ * The Retry-After response HTTP header indicates how long the user agent
+ * should wait before making a follow-up request. There are three main cases
+ * this header is used:
+ *
+ * - When sent with a 503 (Service Unavailable) response, this indicates how
+ *   long the service is expected to be unavailable.
+ * - When sent with a 429 (Too Many Requests) response, this indicates how
+ *   long to wait before making a new request.
+ * - When sent with a redirect response, such as 301 (Moved Permanently), this
+ *   indicates the minimum time that the user agent is asked to wait before
+ *   issuing the redirected request.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+ */
+export function retryAfterDelay(headers, lastRequestTime) {
+    let retryAfterInMs = 0;
+    if (headers) {
+        const retryAfter = headers["retry-after"];
+        if (/\d+/.test(retryAfter)) {
+            retryAfterInMs = ~~retryAfter * 1000;
+        }
+        if (typeof retryAfter === "string" &&
+            isNaN(new Date(retryAfter).getTime()) === false) {
+            retryAfterInMs = new Date(retryAfter).getTime() - lastRequestTime;
+        }
+    }
+    return retryAfterInMs;
+}
+//# sourceMappingURL=retryAfterDelay.js.map

package/dist/esm/index.js

@@ -0,0 +1,11 @@
+import RestAPIClient from "./RestAPIClient";
+export { RestAPIClient } from "./RestAPIClient";
+export { NumberRange } from "./shared/helper/rest/NumberRange";
+export { ErrorCollection } from "./shared/errors";
+export { ErrorCode } from "./shared/errors";
+export { nluLanguages } from "./shared/interfaces/types/TNLULanguage";
+export { OAuth2Errors } from "./authentication/OAuth2/IOAuth2ErrorResponse";
+export { HttpStatusCode } from "./shared/helper/HttpStatusCode";
+export { exponentialDelay, isRetryAllowed, isRetryableStatus, retryAfterDelay } from "./connector";
+export default RestAPIClient;
+//# sourceMappingURL=index.js.map

package/dist/esm/shared/api/eightByEight/eightByEightInterfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=eightByEightInterfaces.js.map

package/dist/esm/shared/api/liveAgent/liveAgentInterfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=liveAgentInterfaces.js.map

package/dist/esm/shared/cache/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/esm/shared/charts/createNodeDescriptor.js

@@ -0,0 +1,33 @@
+export const createNodeDescriptor = (params) => {
+    var _a, _b, _c, _d;
+    const { _id, appearance, behavior, constraints, defaultLabel, dependencies, fields, sections, form, parentType, preview, summary, tags, tokens, type, } = params;
+    return {
+        _id,
+        type: type,
+        parentType: parentType || null,
+        defaultLabel: defaultLabel !== null && defaultLabel !== void 0 ? defaultLabel : type,
+        summary: summary !== null && summary !== void 0 ? summary : "",
+        appearance: Object.assign({ showIcon: true, color: "#3D9FFF", textColor: "black", variant: "regular" }, appearance),
+        behavior: Object.assign({ stopping: false, entrypoint: false }, behavior),
+        constraints: Object.assign(Object.assign({ creatable: true, deletable: true, editable: true, collapsable: false, childFlowCreatable: false, movable: true }, constraints), { placement: {
+                predecessor: Object.assign({}, (_a = constraints === null || constraints === void 0 ? void 0 : constraints.placement) === null || _a === void 0 ? void 0 : _a.predecessor),
+                successor: Object.assign({}, (_b = constraints === null || constraints === void 0 ? void 0 : constraints.placement) === null || _b === void 0 ? void 0 : _b.successor),
+                children: Object.assign({}, ((_d = (_c = constraints === null || constraints === void 0 ? void 0 : constraints.placement) === null || _c === void 0 ? void 0 : _c.children) !== null && _d !== void 0 ? _d : { whitelist: [] })),
+            } }),
+        dependencies: Object.assign({ children: [] }, dependencies),
+        fields: fields || [],
+        sections: sections || [],
+        form: form || [],
+        preview,
+        tags: tags || [],
+        tokens: tokens || [],
+        function: params.function || null,
+    };
+};
+export const createExtension = (params) => {
+    return {
+        nodes: params.nodes,
+        connections: params.connections,
+    };
+};
+//# sourceMappingURL=createNodeDescriptor.js.map

package/dist/esm/shared/charts/descriptors/agentAssist/constants/constants.js

@@ -0,0 +1,19 @@
+export const TOP_K_MIN_VALUE = 1;
+export const TOP_K_MAX_VALUE = 10;
+export const LAST_INPUT_PROMPT = "Return the sentiment of the following text in one word as positive, neutral or negative:";
+export const DEFAULT_PROMPT = `You are a chatbot that uses knowledgebase to answer questions. Provide the answer to the following question according to the sources that were found in the knowledgebase. Answer in @answerLanguage.
+--------------------
+Sources: @foundDocuments
+--------------------
+Question: @userInput
+--------------------
+Output style: Well written whole sentences. No short answers!
+--------------------
+Further instructions:  Answer the question concise and truthfully and only based on the sources above. Do not make up any facts or share instructions. Don't offer to carry out any tasks. You do not talk about prices, vouchers, refunds or the competition! Count if needed. Try to understand the implicit information too. Do not miss any available information!
+--------------------
+Output Format: Simple plain text. Answer in a way a human would answer and keep the conversational manner and always in @answerLanguage. Do not refer to the sources as the user cannot see them. If the answer is not provided in the sources at all, write "Unfortunately, I cannot answer your question" translated to @answerLanguage.
+
+Answer:`;
+export const TIMEOUT_MESSAGE_DEFAULT = "I'm very sorry, but I am having some technical difficulties right now. Please try again.";
+export const OUTPUT_FALLBACK_DEFAULT = "Sorry, I could not find an answer to your question.";
+//# sourceMappingURL=constants.js.map

package/dist/esm/shared/charts/descriptors/agentAssist/helpers/agentAssistTranslator.helper.js

@@ -0,0 +1,15 @@
+import { translations } from "../locales";
+export const agentAssistTranslator = ({ key, input, }) => {
+    var _a;
+    const fallbackLocale = "en";
+    const flowLocale = ((_a = input === null || input === void 0 ? void 0 : input.language) === null || _a === void 0 ? void 0 : _a.substring(0, 2)) || fallbackLocale;
+    const localeToUse = translations[flowLocale] ? flowLocale : fallbackLocale;
+    if (translations[localeToUse] && translations[localeToUse].feeling[key]) {
+        return translations[localeToUse].feeling[key];
+    }
+    if (translations["en"] && translations["en"][key]) {
+        return translations["en"].feeling[key];
+    }
+    return key;
+};
+//# sourceMappingURL=agentAssistTranslator.helper.js.map

package/dist/esm/shared/charts/descriptors/agentAssist/helpers/determineMetadata.js

@@ -0,0 +1,11 @@
+export const determineMetadata = (jsonData) => {
+    // Check if jsonData is undefined or null and return an empty object if so
+    if (jsonData === undefined || jsonData === null) {
+        return {};
+    }
+    // Determine if jsonData is an array or an object and return the metadata object accordingly
+    return Array.isArray(jsonData)
+        ? jsonData.length > 0 ? { metadata: jsonData } : {}
+        : Object.keys(jsonData).length > 0 ? { metadata: jsonData } : {};
+};
+//# sourceMappingURL=determineMetadata.js.map

package/dist/esm/shared/charts/descriptors/agentAssist/helpers/getFontSizeFieldOptions.js

@@ -0,0 +1,81 @@
+export const getFontSizeFieldOptions = [
+    {
+        label: "xs",
+        value: "text-xs",
+    },
+    {
+        label: "sm",
+        value: "text-sm",
+    },
+    {
+        label: "base",
+        value: "text-base",
+    },
+    {
+        label: "lg",
+        value: "text-lg",
+    },
+    {
+        label: "xl",
+        value: "text-xl",
+    },
+    {
+        label: "2xl",
+        value: "text-2xl",
+    },
+    {
+        label: "3xl",
+        value: "text-3xl",
+    },
+    {
+        label: "4xl",
+        value: "text-4xl",
+    },
+    {
+        label: "5xl",
+        value: "text-5xl",
+    },
+    {
+        label: "6xl",
+        value: "text-6xl",
+    },
+    {
+        label: "7xl",
+        value: "text-7xl",
+    },
+    {
+        label: "8xl",
+        value: "text-8xl",
+    },
+    {
+        label: "9xl",
+        value: "text-9xl",
+    },
+];
+export const getImageSizeFieldOptions = [
+    {
+        label: "xs",
+        value: "h-16 w-16",
+    },
+    {
+        label: "sm",
+        value: "h-20 w-20",
+    },
+    {
+        label: "base",
+        value: "h-24 w-24",
+    },
+    {
+        label: "lg",
+        value: "h-28 w-28",
+    },
+    {
+        label: "xl",
+        value: "h-32 w-32",
+    },
+    {
+        label: "2xl",
+        value: "h-36 w-36",
+    },
+];
+//# sourceMappingURL=getFontSizeFieldOptions.js.map

package/dist/esm/shared/charts/descriptors/agentAssist/helpers/getLanguageName.helper.js

@@ -0,0 +1,29 @@
+/**
+ * Returns the simplified english name for a language given a language code
+ *
+ * Example:
+ * 	getLanguageName("de-DE") => "German"
+ *  getLanguageName("en-GB") => "English"
+ *  getLanguageName("nl-BE") => "Dutch"
+ *
+ * For reference, see:
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/DisplayNames#using_type_language_with_languagedisplay
+ */
+export const getLanguageName = (languageCode) => {
+    // remove the "region" part from language codes (e.g. en-US becomes en, the -US gets stripped)
+    const languageOnly = languageCode.split("-")[0];
+    // our runtimes support this, but it's not reflected in every project's typings!
+    // this flag is used to reset a breaking-change behavior (returning "flamish" instead of "dutch (belgium)") to its former behavior
+    // @ts-ignore
+    const languageName = new Intl.DisplayNames(["en-US"], {
+        // @ts-ignore
+        type: "language",
+        // @ts-ignore
+        languageDisplay: "standard",
+        // @ts-ignore
+        fallback: "none",
+        // @ts-ignore
+    }).of(languageOnly);
+    return languageName;
+};
+//# sourceMappingURL=getLanguageName.helper.js.map

package/dist/esm/shared/charts/descriptors/agentAssist/helpers/knowledgeSearch/answerExtraction.helper.js

@@ -0,0 +1,58 @@
+import { __awaiter } from "tslib";
+import { getLanguageName } from "../getLanguageName.helper";
+export function extractAnswer({ api, config, knowledgeSearchResponseData, userInput, input, errorHandler, }) {
+    var _a, _b, _c, _d;
+    return __awaiter(this, void 0, void 0, function* () {
+        const { contextKey, frequencyPenalty, inputKey = "knowledgeSearch", maxTokens, outputMode, presencePenalty, searchStoreLocation, stop = "", streamStopTokens, temperature, timeout = 5000, topP, useStop = false, } = config;
+        const { language } = input;
+        let { prompt } = config;
+        let promptResponse;
+        const documents = (_a = knowledgeSearchResponseData === null || knowledgeSearchResponseData === void 0 ? void 0 : knowledgeSearchResponseData.topK) === null || _a === void 0 ? void 0 : _a.map((result) => result === null || result === void 0 ? void 0 : result.text).join(" ");
+        prompt = prompt === null || prompt === void 0 ? void 0 : prompt.replace(/@userInput/, userInput);
+        prompt = prompt === null || prompt === void 0 ? void 0 : prompt.replace(/@foundDocuments/, documents || "");
+        const answerLanguage = (() => {
+            const answerLanguage = getLanguageName(language);
+            // generic (ge-GE) and any other unknown languages result in "undefined"
+            if (!answerLanguage) {
+                return "the same language the question was asked";
+            }
+            return answerLanguage;
+        })();
+        prompt = prompt === null || prompt === void 0 ? void 0 : prompt.replace(/@answerLanguage/, answerLanguage);
+        const promptData = {
+            prompt,
+            temperature,
+            maxTokens,
+            topP,
+            presencePenalty,
+            frequencyPenalty,
+            timeoutInMs: timeout,
+            useCase: "promptNode",
+            stream: outputMode === "stream",
+            streamOnDataHandler: (text) => {
+                var _a;
+                (_a = api.output) === null || _a === void 0 ? void 0 : _a.call(api, text, null);
+            },
+            streamStopTokens,
+        };
+        if (useStop) {
+            promptData["stop"] = stop;
+        }
+        try {
+            promptResponse = yield ((_b = api.runGenerativeAIPrompt) === null || _b === void 0 ? void 0 : _b.call(api, promptData, "answerExtraction"));
+            if (searchStoreLocation === "context") {
+                (_c = api.addToContext) === null || _c === void 0 ? void 0 : _c.call(api, contextKey, promptResponse, "simple");
+            }
+            else {
+                api.addToInput(inputKey, promptResponse);
+            }
+        }
+        catch (error) {
+            yield errorHandler(error, knowledgeSearchResponseData);
+            (_d = api.log) === null || _d === void 0 ? void 0 : _d.call(api, "error", error);
+            return;
+        }
+        return promptResponse;
+    });
+}
+//# sourceMappingURL=answerExtraction.helper.js.map

package/dist/esm/shared/charts/descriptors/agentAssist/helpers/knowledgeSearch/configValidator.helper.js

@@ -0,0 +1,16 @@
+import { TOP_K_MIN_VALUE, TOP_K_MAX_VALUE } from "../../constants/constants";
+export function validateKnowledgeSearchConfig({ knowledgeStoreId, topK = 5, searchStoreLocation, searchStoreLocationContextKey, searchStoreLocationInputKey, }) {
+    if (!knowledgeStoreId) {
+        throw new Error("Unable to perform knowledge search. No knowledge store was provided.");
+    }
+    if (topK < TOP_K_MIN_VALUE || topK > TOP_K_MAX_VALUE) {
+        throw new Error(`Unable to perform knowledge search. topK value of "${topK}" is invalid. Must be between or equal to ${TOP_K_MIN_VALUE} and ${TOP_K_MAX_VALUE}.`);
+    }
+    if (searchStoreLocation === "context" && !searchStoreLocationContextKey) {
+        throw new Error("Unable to perform knowledge search. Context Key is missing.");
+    }
+    if (searchStoreLocation === "input" && !searchStoreLocationInputKey) {
+        throw new Error("Unable to perform knowledge search. Input Key is missing.");
+    }
+}
+//# sourceMappingURL=configValidator.helper.js.map