wingbot 3.66.4 → 3.67.1

package/index.js

@@ -3,7 +3,7 @@
  */
 'use strict';
 
-/** @typedef {import('./src/Processor').ProcessorOptions} ProcessorOptions */
+/** @typedef {import('./src/Processor').ProcessorOptions<Router|BuildRouter>} ProcessorOptions */
 
 const Processor = require('./src/Processor');
 const Router = require('./src/Router');
@@ -19,6 +19,7 @@ const CustomEntityDetectionModel = require('./src/wingbot/CustomEntityDetectionM
 const ConversationTester = require('./src/ConversationTester');
 const { asserts } = require('./src/testTools');
 const BuildRouter = require('./src/BuildRouter');
+const ChatGpt = require('./src/ChatGpt');
 const MockAiModel = require('./src/MockAiModel');
 const ReturnSender = require('./src/ReturnSender');
 const CallbackAuditLog = require('./src/CallbackAuditLog');
@@ -126,6 +127,7 @@ module.exports = {
     ButtonTemplate,
     GenericTemplate,
     BaseTemplate,
+    ChatGpt,
 
     // tests
     ConversationTester,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.66.4",
+  "version": "3.67.1",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "scripts": {

package/plugins/ai.wingbot.openai/plugin.js

@@ -5,6 +5,7 @@
 
 const fetch = require('node-fetch').default;
 const Responder = require('../../src/Responder');
+const ChatGpt = require('../../src/ChatGpt');
 const compileWithState = require('../../src/utils/compileWithState');
 
 const MSG_REPLACE = '#MSG-REPLACE#';
@@ -13,15 +14,11 @@ const CHAR_LIM = 4096;
 
 function chatgptPlugin (params, configuration = {}) {
     const {
-        openAiEndpoint = null,
+        openAiEndpoint = undefined,
         openAiApiKey = null
     } = configuration;
 
     async function chatgpt (req, res) {
-        const content = req.text();
-
-        const charLim = params.charLim || CHAR_LIM;
-
         const token = compileWithState(req, res, params.token).trim();
 
         // gpt-3.5-turbo-0301 gpt-3.5-turbo
@@ -30,17 +27,13 @@ function chatgptPlugin (params, configuration = {}) {
         const system = compileWithState(req, res, params.system).trim();
 
         // 0 - 2
-        const temperature = parseFloat(compileWithState(req, res, params.temperature).trim().replace(',', '.') || '1') || 1;
+        const temperature = parseFloat(compileWithState(req, res, params.temperature).trim().replace(',', '.') || '1') || undefined;
         // presence_penalty between -2.0 and 2.0
-        const presence = parseFloat(compileWithState(req, res, params.presence).trim().replace(',', '.') || '0') || 0;
-
-        const maxTokens = parseFloat(compileWithState(req, res, params.maxTokens).trim() || '512') || 512;
+        const presence = parseFloat(compileWithState(req, res, params.presence).trim().replace(',', '.') || '0') || undefined;
 
-        const limit = parseInt(compileWithState(req, res, params.limit).trim() || '10', 10) || 10;
+        const requestTokens = parseFloat(compileWithState(req, res, params.maxTokens).trim() || '512') || undefined;
 
-        const user = `${req.pageId}|${req.senderId}`;
-
-        const systemAfter = compileWithState(req, res, params.systemAfter).trim();
+        const transcriptLength = parseInt(compileWithState(req, res, params.limit).trim() || '10', 10) || 10;
 
         const replacedAnnotation = `${params.annotation || ''}`.replace(/\{\{message\}\}/g, MSG_REPLACE);
         const annotation = compileWithState(req, res, replacedAnnotation).trim();
@@ -53,157 +46,27 @@ function chatgptPlugin (params, configuration = {}) {
             || continueConfig.find((c) => ['default', '']
                 .includes(`${c.lang || ''}`.trim().toLowerCase()));
 
-        let body;
+        const gpt = new ChatGpt({
+            fetch: params.fetch,
+            model,
+            presencePenalty: presence,
+            requestTokens,
+            temperature,
+            transcriptLength,
+            openAiEndpoint,
+            ...(openAiEndpoint
+                ? { apiKey: token || openAiApiKey }
+                : { authorization: token || openAiApiKey })
+        });
 
         try {
-            res.setFlag('gpt');
-            res.typingOn();
-
-            body = {
-                model,
-                frequency_penalty: 0,
-                presence_penalty: presence,
-                max_tokens: maxTokens,
-                temperature,
-                user
-            };
-
-            const onlyFlag = Math.sign(limit) === -1 ? 'gpt' : null;
-
-            const ts = await res.getTranscript(Math.abs(limit), onlyFlag);
-
-            let total = (system ? system.length : 0)
-                + (systemAfter ? systemAfter.length : 0)
-                + maxTokens
-                + content.length;
-
-            for (let i = ts.length - 1; i >= 0; i--) {
-                total += ts[i].text.length;
-                if (total > charLim) {
-                    ts.splice(i, 1);
-                }
-            }
-
-            const messages = [
-                ...(system ? [{ role: 'system', content: system }] : []),
-                ...ts.map((t) => ({ role: t.fromBot ? 'assistant' : 'user', content: t.text })),
-                { role: 'user', content },
-                ...(systemAfter ? [{ role: 'system', content: systemAfter }] : [])
-            ];
-
-            Object.assign(body, { messages });
-
-            const useFetch = params.fetch || fetch;
-
-            const apiUrl = openAiEndpoint
-                ? `${openAiEndpoint}/chat/completions?api-version=2023-03-15-preview`
-                : 'https://api.openai.com/v1/chat/completions';
-
-            const response = await useFetch(apiUrl, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...(openAiEndpoint
-                        ? { 'api-key': token || openAiApiKey }
-                        : { Authorization: `Bearer ${token || openAiApiKey}` })
-                },
-                body: JSON.stringify(body)
+            await gpt.respond(req, res, {
+                system,
+                persona,
+                continueReply,
+                annotation
             });
-
-            const data = await response.json();
-
-            if (response.status !== 200
-                || !Array.isArray(data.choices)) {
-                const { status, statusText } = response;
-                // eslint-disable-next-line no-console
-                console.log('chat gpt error', {
-                    status, statusText, data, apiUrl
-                });
-                throw new Error(`Chat GPT ${status}`);
-            }
-
-            // eslint-disable-next-line no-console
-            console.log('chat gpt', JSON.stringify(data));
-
-            const sent = data.choices
-                .filter((ch) => ch.message && ch.message.role === 'assistant' && ch.message.content)
-                .map((ch) => {
-
-                    let sliced = data.usage && data.usage.completion_tokens >= maxTokens;
-
-                    let filtered = ch.message.content
-                        .replace(/\n\n/g, '\n')
-                        .split(/\n+(?!-)/g)
-                        .filter((t) => !!t.trim());
-
-                    if (filtered.length > 2) {
-                        filtered = filtered.slice(0, filtered.length - 1);
-                        sliced = true;
-                    }
-
-                    if (persona) {
-                        res.setPersona({ name: persona });
-                    }
-
-                    filtered
-                        .forEach((t, fi) => {
-                            let trim = t.trim();
-
-                            if (annotation) {
-                                // replace the annotation first
-
-                                const replacements = annotation.split(MSG_REPLACE);
-                                const last = replacements.length > 1
-                                    ? replacements.length - 1
-                                    : replacements.length;
-                                replacements.forEach((r, i) => {
-                                    const foundI = trim.indexOf(r.trim(), i === last
-                                        ? trim.length - r.trim().length
-                                        : 0);
-
-                                    if (foundI === -1
-                                        || (i === 0 && foundI > 0)
-                                        || (i === last && (trim.length - foundI - r.length) > 0)) {
-                                        return;
-                                    }
-
-                                    trim = trim.replace(r.trim(), '').trim();
-                                });
-                            }
-
-                            if (annotation && annotation.includes(MSG_REPLACE)) {
-                                trim = annotation.replace(MSG_REPLACE, trim);
-                            } else if (annotation) {
-                                trim = `${annotation} ${trim}`;
-                            }
-
-                            res.text(trim, sliced && fi === (filtered.length - 1) && continueReply
-                                ? [
-                                    {
-                                        title: continueReply.title,
-                                        action: res.currentAction()
-                                    }
-                                ]
-                                : null);
-                        });
-
-                    if (persona) {
-                        res.setPersona({ name: null });
-                    }
-
-                    return ch;
-                });
-
-            if (sent.length === 0) {
-                const { status, statusText } = response;
-                // eslint-disable-next-line no-console
-                console.log('chat gpt nothing to send', { status, statusText, data });
-                throw new Error('Chat GPT empty');
-            }
-
         } catch (e) {
-            // eslint-disable-next-line no-console
-            console.error('chat gpt fail', e, body);
             await res.run('fallback');
         }
 

package/src/Ai.js

@@ -51,9 +51,15 @@ let uq = 1;
 // eslint-disable-next-line max-len
 /** @typedef {import('./wingbot/CustomEntityDetectionModel').WordEntityDetector} WordEntityDetector */
 
+/**
+ * @typedef {object} WordDetectorData
+ * @prop {WordEntityDetector} detector
+ * @prop {number} [maxWordCount]
+ */
+
 /**
  * @callback WordEntityDetectorFactory
- * @returns {Promise<WordEntityDetector>}
+ * @returns {Promise<WordEntityDetector|WordDetectorData>}
  */
 
 /** @typedef {[string,EntityDetector|RegExp,DetectorOptions]} DetectorArgs */
@@ -90,6 +96,8 @@ class Ai {
          */
         this._wordEntityDetector = null;
 
+        this._wordEntityDetectorMaxWordCount = 0;
+
         /**
          * Upper threshold - for match method and for navigate method
          *
@@ -289,19 +297,33 @@ class Ai {
 
     /**
      *
-     * @param {WordEntityDetector|WordEntityDetectorFactory} wordEntityDetector
+     * @param {WordEntityDetector|WordEntityDetectorFactory|WordDetectorData} wordEntityDetector
      */
     setWordEntityDetector (wordEntityDetector) {
-        if (wordEntityDetector.length === 0) {
+        if (typeof wordEntityDetector === 'function' && wordEntityDetector.length === 0) {
             // @ts-ignore
             this._wordEntityDetectorFactory = wordEntityDetector;
             return this;
         }
 
-        this._wordEntityDetector = wordEntityDetector;
+        let detector;
+        if (typeof wordEntityDetector === 'object') {
+            ({ detector } = wordEntityDetector);
+            this._wordEntityDetectorMaxWordCount = Math.max(
+                this._wordEntityDetectorMaxWordCount,
+                wordEntityDetector.maxWordCount || 0
+            );
+        } else {
+            detector = wordEntityDetector;
+        }
+
+        // @ts-ignore
+        this._wordEntityDetector = detector;
 
         for (const model of this._keyworders.values()) {
-            model.wordEntityDetector = wordEntityDetector;
+            // @ts-ignore
+            model.wordEntityDetector = detector;
+            model.maxWordCount = Math.max(model.maxWordCount, this._wordEntityDetectorMaxWordCount);
         }
         return this;
     }
@@ -684,15 +706,12 @@ class Ai {
      */
     preloadDetectors () {
         if (this._wordEntityDetectorFactory === null || this._wordEntityDetector) {
-            return Promise.resolve();
+            return Promise.resolve(this._wordEntityDetector);
         }
 
         const promise = this._wordEntityDetectorFactory()
             .then((detector) => {
-                this._wordEntityDetector = detector;
-                for (const model of this._keyworders.values()) {
-                    model.wordEntityDetector = detector;
-                }
+                this.setWordEntityDetector(detector);
                 return detector;
             })
             .catch((e) => {

package/src/ChatGpt.js

@@ -0,0 +1,486 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+const nodeFetch = require('node-fetch').default;
+const util = require('util');
+const { PHONE_REGEX, EMAIL_REGEX } = require('./systemEntities/regexps');
+
+/** @typedef {import('node-fetch').default} Fetch */
+/** @typedef {import('./Request')} Request */
+/** @typedef {import('./Responder')} Responder */
+/** @typedef {import('./Responder').QuickReply} QuickReply */
+
+/**
+ * @typedef {object} Transcript
+ * @prop {string} text
+ * @prop {boolean} fromBot
+ */
+
+/**
+ * @typedef {object} GeneralOptions
+ * @prop {Fetch} [fetch]
+ * @prop {string} [defaultUser]
+ * @prop {string} [openAiEndpoint]
+ * @prop {string} [apiVersion]
+ * @prop {string} [apiKey] // for microsoft services
+ * @prop {string} [authorization] // for chat gpt api
+ */
+
+/** @typedef {'gpt-3.5-turbo'|'gpt-4'|'gpt-4-32k'|'gpt-3.5-turbo-16k'|string} ChatGPTModel */
+
+/**
+ * @typedef {object} DefaultRequestOptions
+ * @prop {ChatGPTModel} [model]
+ * @prop {number} [presencePenalty=0.0]
+ * @prop {number} [requestTokens=256]
+ * @prop {number} [tokensLimit=4096]
+ * @prop {number} [temperature=1.0]
+ * @prop {number} [transcriptLength=-5]
+ */
+
+/**
+ * @typedef {object} OptionsExtension
+ * @prop {FNAnnotation[]} [functions]
+ *
+ * @typedef {OptionsExtension & DefaultRequestOptions} RequestOptions
+ */
+
+/**
+ * @typedef {GeneralOptions & DefaultRequestOptions} ChatGptOptions
+ */
+
+/**
+ * @typedef {object} Message
+ * @prop {'system'|'user'|'assistant'|string} role
+ * @prop {string} content
+ */
+
+/**
+ * @typedef {object} ChatGPTChoice
+ * @prop {'stop'|'length'|'function_call'|'content_filter'|null} finish_reason
+ * @prop {number} index
+ * @prop {Message} message
+ */
+
+/**
+ * @typedef {object} ChatGPTUsage
+ * @prop {number} completion_tokens
+ * @prop {number} prompt_tokens
+ * @prop {number} total_tokens
+ */
+
+/**
+ * @typedef {object} ChatGPTResponse
+ * @prop {ChatGPTChoice[]} choices
+ * @prop {number} created
+ * @prop {ChatGPTModel} model
+ * @prop {'text_completion'} object
+ * @prop {ChatGPTUsage} usage
+ */
+
+/**
+ * @typedef {object} Logger
+ * @prop {Function} log
+ * @prop {Function} error
+ */
+
+/**
+ * @typedef {object} SlicedAnnotation
+ * @prop {boolean} [sliced]
+ *
+ * @typedef {string[] & SlicedAnnotation} StringArrayWithSliced
+ */
+
+/**
+ * @typedef {object} ContinueReply
+ * @prop {string} title
+ * @prop {string} [action]
+ */
+
+/**
+ * @typedef {object} Persona
+ * @prop {string} [profile_pic_url]
+ * @prop {string} [name]
+ */
+
+/**
+ * @typedef {object} ReplyConfiguration
+ * @prop {string} [system]
+ * @prop {string} [annotation]
+ * @prop {ContinueReply|boolean} [continueReply]
+ * @prop {string|Persona} [persona]
+ * @prop {boolean} [anonymize=true]
+ */
+
+/**
+ * @typedef {object} FNScalarParam
+ * @prop {'string'|'number'|'boolean'} type
+ * @prop {string[]} [enum]
+ * @prop {string} [description]
+ */
+
+/**
+ * @typedef {object} FNArrayParam
+ * @prop {'array'} type
+ * @prop {string} [description]
+ * @prop {FNParam} items
+ */
+
+/**
+ * @typedef {object} FNObjectParam
+ * @prop {'object'} type
+ * @prop {{ [key: string]: FNParam }} properties
+ * @prop {string[]} [required]
+ * @prop {string} [description]
+ */
+
+/** @typedef {FNScalarParam|FNObjectParam|FNArrayParam} FNParam */
+
+/**
+ * @typedef {object} FNAnnotation
+ * @prop {string} name
+ * @prop {string} description
+ * @prop {FNParam} parameters
+ */
+
+/**
+ * @class ChatGpt
+ */
+class ChatGpt {
+
+    /**
+     *
+     * @param {ChatGptOptions} options
+     * @param {Logger} log
+     */
+    constructor (options, log = console) {
+        const {
+            fetch = nodeFetch,
+            defaultUser = null,
+            openAiEndpoint = 'https://api.openai.com/v1',
+            apiKey,
+            authorization,
+            ...rest
+        } = options;
+
+        this._apiKey = apiKey;
+        this._authorization = authorization;
+
+        this._fetch = fetch;
+
+        this._openAiEndpoint = openAiEndpoint;
+
+        this._defaultUser = defaultUser;
+
+        /** @type {Required<DefaultRequestOptions>} */
+        this._options = {
+            requestTokens: 256,
+            tokensLimit: 4096,
+            presencePenalty: 0.0, // -2.0-2.0
+            temperature: 1.0,
+            model: 'gpt-3.5-turbo',
+            transcriptLength: -5,
+            ...rest
+        };
+
+        this._logger = log;
+
+        this.MSG_REPLACE = '#MSG-REPLACE#';
+
+        this.GPT_FLAG = 'gpt';
+
+        this._anonymizeRegexps = [
+            { replacement: '@PHONE', regex: new RegExp(PHONE_REGEX.source, 'g') },
+            { replacement: '@EMAIL', regex: new RegExp(EMAIL_REGEX.source, 'g') }
+        ];
+    }
+
+    _log (msg, ...args) {
+        if (this._logger === console) {
+
+            this._logger.log(msg, ...args.map((arg) => util.inspect(arg, {
+                showHidden: false, depth: null, colors: true
+            })));
+        } else {
+            this._logger.log(msg, ...args);
+        }
+    }
+
+    /**
+     *
+     * @param {Responder} res
+     * @param {number} limit
+     * @param {boolean} anonymize
+     * @returns {Promise<Transcript[]>}
+     */
+    async getTranscript (
+        res,
+        limit = this._options.transcriptLength,
+        anonymize = true
+    ) {
+        const onlyFlag = Math.sign(limit) === -1 ? 'gpt' : null;
+        const transcript = await res.getTranscript(Math.abs(limit), onlyFlag);
+
+        if (!anonymize) {
+            return transcript;
+        }
+
+        return transcript.map((t) => ({
+            ...t,
+            text: this._anonymizeRegexps
+                .reduce((text, { replacement, regex }) => {
+                    const replaced = text.replace(regex, replacement);
+                    return replaced;
+                }, t.text)
+        }));
+    }
+
+    /**
+     *
+     * @param {string} content
+     * @param {string} [system]
+     * @param {Transcript[]} [transcript]
+     * @param {RequestOptions} [requestOptions]
+     * @param {string|Request} [user]
+     * @returns {Promise<ChatGPTChoice>}
+     */
+    async request (content, system = null, transcript = [], requestOptions = {}, user = null) {
+        const {
+            requestTokens,
+            tokensLimit,
+            model,
+            presencePenalty,
+            temperature,
+            functions = []
+        } = {
+            ...this._options,
+            ...requestOptions
+        };
+
+        const maxTokens = Math.min(requestTokens, tokensLimit);
+
+        let body;
+
+        try {
+            body = {
+                model,
+                frequency_penalty: 0,
+                presence_penalty: presencePenalty,
+                max_tokens: maxTokens,
+                temperature,
+                functions
+            };
+
+            if (typeof user === 'string') {
+                Object.assign(body, { user });
+            } else if (user) {
+                Object.assign(body, { user: `${user.pageId}|${user.senderId}` });
+            } else if (this._defaultUser) {
+                Object.assign(body, { user: this._defaultUser });
+            }
+
+            let total = (system ? system.length : 0)
+                + maxTokens
+                + content.length;
+
+            const ts = transcript.slice();
+
+            for (let i = ts.length - 1; i >= 0; i--) {
+                total += ts[i].text.length;
+                if (total > tokensLimit) {
+                    ts.splice(i, 1);
+                }
+            }
+
+            /** @type {Message[]} */
+            const messages = [
+                ...(system ? [{ role: 'system', content: system }] : []),
+                ...ts.map((t) => ({ role: t.fromBot ? 'assistant' : 'user', content: t.text })),
+                { role: 'user', content }
+            ];
+
+            Object.assign(body, { messages });
+
+            const apiUrl = `${this._openAiEndpoint}/chat/completions${this._apiKey ? '?api-version=2023-03-15-preview' : ''}`;
+
+            this._log('#GPT request', body);
+
+            const response = await this._fetch(apiUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(this._apiKey
+                        ? { 'api-key': this._apiKey }
+                        : { Authorization: `Bearer ${this._authorization}` })
+                },
+                body: JSON.stringify(body)
+            });
+
+            /** @type {ChatGPTResponse} */
+            const data = await response.json();
+
+            if (response.status !== 200
+                || !Array.isArray(data.choices)) {
+                const { status, statusText } = response;
+
+                this._logger.error('#GPT failed', {
+                    status, statusText, data, body
+                });
+                throw new Error(`Chat GPT ${status}`);
+            }
+
+            const [choice] = data.choices;
+
+            this._log('#GPT response', { choice, data });
+
+            return choice;
+        } catch (e) {
+            this._logger.error('#GPT failed', e, body);
+            throw e;
+        }
+    }
+
+    /**
+     *
+     * @param {ChatGPTChoice} choice
+     * @param {string} [annotation]
+     * @returns {StringArrayWithSliced}
+     */
+    toMessages (choice, annotation = null) {
+        let sliced = choice.finish_reason === 'length';
+
+        let filtered = choice.message.content
+            .replace(/\n\n/g, '\n')
+            .split(/\n+(?!-)/g)
+            .filter((t) => !!t.trim());
+
+        if (sliced && filtered.length > 1) {
+            filtered = filtered.slice(0, filtered.length - 1);
+            sliced = true;
+        }
+
+        filtered = filtered
+            .map((t) => {
+                let trim = t.trim();
+
+                if (annotation) {
+                    // replace the annotation first
+
+                    const replacements = annotation.split(this.MSG_REPLACE);
+
+                    const last = replacements.length > 1
+                        ? replacements.length - 1
+                        : replacements.length;
+
+                    replacements.forEach((r, i) => {
+                        const foundI = trim.indexOf(r.trim(), i === last
+                            ? trim.length - r.trim().length
+                            : 0);
+
+                        if (foundI === -1
+                            || (i === 0 && foundI > 0)
+                            || (i === last && (trim.length - foundI - r.length) > 0)) {
+                            return;
+                        }
+
+                        trim = trim.replace(r.trim(), '').trim();
+                    });
+                }
+
+                if (annotation && annotation.includes(this.MSG_REPLACE)) {
+                    trim = annotation.replace(this.MSG_REPLACE, trim);
+                } else if (annotation) {
+                    trim = `${annotation} ${trim}`;
+                }
+
+                return trim;
+            });
+
+        return Object.assign(filtered, { sliced });
+    }
+
+    /**
+     *
+     * @param {Responder} res
+     * @param {string[]} messages
+     * @param {QuickReply[]} [quickReplies]
+     */
+    sendMessages (res, messages, quickReplies = null) {
+        messages.forEach((text, i) => {
+            const addQuickReply = i === (messages.length - 1);
+            res.text(text, addQuickReply ? quickReplies : null);
+        });
+    }
+
+    /**
+     *
+     * @param {Request} req
+     * @param {Responder} res
+     * @param {ReplyConfiguration} [replyConfig]
+     * @param {RequestOptions} [options]
+     */
+    async respond (req, res, replyConfig = {}, options = {}) {
+        res.setFlag(this.GPT_FLAG);
+        res.typingOn();
+
+        const {
+            transcriptLength
+        } = {
+            ...this._options,
+            ...options
+        };
+
+        const { persona, continueReply, anonymize } = replyConfig;
+
+        const content = req.text();
+
+        const transcript = await this.getTranscript(res, transcriptLength, anonymize);
+        const choice = await this.request(content, replyConfig.system, transcript, options);
+
+        const messages = this.toMessages(choice, replyConfig.annotation);
+
+        if (typeof persona === 'string') {
+            res.setPersona({ name: persona });
+        } else if (persona) {
+            res.setPersona(persona);
+        }
+
+        const { sliced } = messages;
+
+        let qrs;
+
+        if (!continueReply) {
+            qrs = null;
+        } else if (continueReply === true) {
+            qrs = [];
+        } else if (typeof continueReply === 'object') {
+            qrs = [{
+                title: continueReply.title,
+                action: continueReply.action || res.currentAction()
+            }];
+        }
+
+        if (messages.length === 0) {
+            const err = new Error('#GPT nothing to send');
+            this._logger.error('#GPT nothing to send', err, { choice, content });
+            throw err;
+        }
+
+        this.sendMessages(res, messages, qrs);
+
+        if (persona) {
+            res.setPersona({ name: null });
+        }
+
+        return {
+            messages,
+            sliced,
+            choice
+        };
+    }
+
+}
+
+module.exports = ChatGpt;

package/src/systemEntities/email.js

@@ -3,11 +3,17 @@
  */
 'use strict';
 
+const { EMAIL_REGEX } = require('./regexps');
+
 /** @typedef {import('../wingbot/CustomEntityDetectionModel').EntityDetector} EntityDetector */
 /** @typedef {import('../wingbot/CustomEntityDetectionModel').DetectorOptions} DetectorOptions */
 
 /** @type {[string,EntityDetector|RegExp,DetectorOptions]} */
-module.exports = ['email', /(?<=(\s|^|:))[a-zA-Z0-9!#$%&'*+\-=?^_`{|}~"][^@:\s]*@[^.@\s]+\.[^@\s,]+/, {
-    anonymize: true,
-    clearOverlaps: true
-}];
+module.exports = [
+    'email',
+    EMAIL_REGEX,
+    {
+        anonymize: true,
+        clearOverlaps: true
+    }
+];

package/src/systemEntities/phone.js

@@ -3,13 +3,15 @@
  */
 'use strict';
 
+const { PHONE_REGEX } = require('./regexps');
+
 /** @typedef {import('../wingbot/CustomEntityDetectionModel').EntityDetector} EntityDetector */
 /** @typedef {import('../wingbot/CustomEntityDetectionModel').DetectorOptions} DetectorOptions */
 
 /** @type {[string,EntityDetector|RegExp,DetectorOptions]} */
 module.exports = [
     'phone',
-    /((00|\+)[\s-]?[0-9]{1,4}[\s-]?)?([0-9]{3,4}[\s-]?([0-9]{2,3}[\s-]?[0-9]{2}[\s-]?[0-9]{2,3}|[0-9]{3,4}[\s-]?[0-9]{3,4}))(?=(\s|$|[,!.?\-:]))/,
+    PHONE_REGEX,
     {
         anonymize: true,
         clearOverlaps: true,

package/src/systemEntities/regexps.js

@@ -0,0 +1,12 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+const PHONE_REGEX = /((00|\+)[\s-]?[0-9]{1,4}[\s-]?)?([0-9]{3,4}[\s-]?([0-9]{2,3}[\s-]?[0-9]{2}[\s-]?[0-9]{2,3}|[0-9]{3,4}[\s-]?[0-9]{3,4}))(?=(\s|$|[,!.?\-:]))/;
+const EMAIL_REGEX = /(?<=(\s|^|:))[a-zA-Z0-9!#$%&'*+\-=?^_`{|}~"][^@:\s]*@[^.@\s]+\.[^@\s,]+/;
+
+module.exports = {
+    PHONE_REGEX,
+    EMAIL_REGEX
+};

package/src/wingbot/CustomEntityDetectionModel.js

@@ -68,6 +68,7 @@ const { iterateThroughWords } = require('../utils/ai');
  * @param {DetectedEntity[]} entities
  * @param {number} startIndex
  * @param {string} prefix
+ * @returns {DetectedEntity[]}
  */
 
 /**
@@ -403,7 +404,8 @@ class CustomEntityDetectionModel {
         let entities = prevEnts.slice();
         if (this.wordEntityDetector) {
             for (const [s, startIndex] of iterateThroughWords(text, this.maxWordCount)) {
-                this.wordEntityDetector(s, entities, startIndex, this.prefix);
+                const ents = this.wordEntityDetector(s, prevEnts, startIndex, this.prefix);
+                entities.push(...ents);
             }
         }