wingbot 3.66.3 → 3.67.0

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.3",
+  "version": "3.67.0",
   "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

@@ -10,8 +10,6 @@ const { deepEqual } = require('./utils/deepMapTools');
 const systemEntities = require('./systemEntities');
 const CustomEntityDetectionModel = require('./wingbot/CustomEntityDetectionModel');
 
-const DEFAULT_PREFIX = 'default';
-
 let uq = 1;
 
 /** @typedef {import('./AiMatching').Compare} Compare */
@@ -49,9 +47,15 @@ let uq = 1;
 /** @typedef {import('./wingbot/CustomEntityDetectionModel').Phrases} Phrases */
 /** @typedef {import('./wingbot/CustomEntityDetectionModel').EntityDetector} EntityDetector */
 /** @typedef {import('./wingbot/CustomEntityDetectionModel').DetectorOptions} DetectorOptions */
+/** @typedef {import('./wingbot/CustomEntityDetectionModel').Entity} Entity */
 // eslint-disable-next-line max-len
 /** @typedef {import('./wingbot/CustomEntityDetectionModel').WordEntityDetector} WordEntityDetector */
 
+/**
+ * @callback WordEntityDetectorFactory
+ * @returns {Promise<WordEntityDetector>}
+ */
+
 /** @typedef {[string,EntityDetector|RegExp,DetectorOptions]} DetectorArgs */
 
 /**
@@ -76,7 +80,13 @@ class Ai {
 
         /**
          * @private
-         * @type {WordEntityDetector}
+         * @type {WordEntityDetectorFactory}
+         */
+        this._wordEntityDetectorFactory = null;
+
+        /**
+         * @private
+         * @type {WordEntityDetector|Promise<WordEntityDetector>}
          */
         this._wordEntityDetector = null;
 
@@ -140,6 +150,37 @@ class Ai {
          * @type {AiMatching}
          */
         this.matcher = new AiMatching(this);
+
+        /**
+         * @type {string}
+         */
+        this.DEFAULT_PREFIX = 'default';
+    }
+
+    /**
+     *
+     * @param {string} text
+     * @param {string|Request} prefix
+     * @returns {Promise<Entity[]>}
+     */
+    async detectEntities (text, prefix = this.DEFAULT_PREFIX) {
+        let model;
+
+        if (typeof prefix === 'string') {
+            model = this._keyworders.get(prefix);
+        } else {
+            const usePrefix = this.getPrefix(this.DEFAULT_PREFIX, prefix);
+            model = this._keyworders.get(usePrefix);
+        }
+
+        if (!model) {
+            return [];
+        }
+
+        const entities = await model.resolveEntities(text);
+
+        // @ts-ignore
+        return entities;
     }
 
     /**
@@ -192,7 +233,7 @@ class Ai {
      * @returns {T}
      * @memberOf Ai
      */
-    register (model, prefix = 'default') {
+    register (model, prefix = this.DEFAULT_PREFIX) {
         /** @type {T} */
         let modelObj;
 
@@ -210,7 +251,10 @@ class Ai {
 
         this._keyworders.set(prefix, modelObj);
 
-        modelObj.wordEntityDetector = this._wordEntityDetector;
+        if (typeof this._wordEntityDetector === 'function') {
+            modelObj.wordEntityDetector = this._wordEntityDetector;
+        }
+
         for (const entityArgs of this._detectors.values()) {
             modelObj.setEntityDetector(...entityArgs);
         }
@@ -245,9 +289,15 @@ class Ai {
 
     /**
      *
-     * @param {WordEntityDetector} wordEntityDetector
+     * @param {WordEntityDetector|WordEntityDetectorFactory} wordEntityDetector
      */
     setWordEntityDetector (wordEntityDetector) {
+        if (wordEntityDetector.length === 0) {
+            // @ts-ignore
+            this._wordEntityDetectorFactory = wordEntityDetector;
+            return this;
+        }
+
         this._wordEntityDetector = wordEntityDetector;
 
         for (const model of this._keyworders.values()) {
@@ -286,7 +336,7 @@ class Ai {
      *
      * @param {string} [prefix]
      */
-    deregister (prefix = 'default') {
+    deregister (prefix = this.DEFAULT_PREFIX) {
         this._keyworders.delete(prefix);
     }
 
@@ -298,7 +348,7 @@ class Ai {
      * @returns {CustomEntityDetectionModel}
      * @memberOf Ai
      */
-    getModel (prefix = 'default') {
+    getModel (prefix = this.DEFAULT_PREFIX) {
         const model = this._keyworders.get(prefix);
         if (!model) {
             throw new Error(`Model ${prefix} not registered yet. Register the model first.`);
@@ -592,7 +642,8 @@ class Ai {
         };
     }
 
-    _getModelForRequest (req, isConfident = req.isConfidentInput(), defaultModel = DEFAULT_PREFIX) {
+    // eslint-disable-next-line max-len
+    _getModelForRequest (req, isConfident = req.isConfidentInput(), defaultModel = this.DEFAULT_PREFIX) {
         if (isConfident) {
             return null;
         }
@@ -627,6 +678,35 @@ class Ai {
         };
     }
 
+    /**
+     *
+     * @returns {Promise}
+     */
+    preloadDetectors () {
+        if (this._wordEntityDetectorFactory === null || this._wordEntityDetector) {
+            return Promise.resolve();
+        }
+
+        const promise = this._wordEntityDetectorFactory()
+            .then((detector) => {
+                this._wordEntityDetector = detector;
+                for (const model of this._keyworders.values()) {
+                    model.wordEntityDetector = detector;
+                }
+                return detector;
+            })
+            .catch((e) => {
+                // eslint-disable-next-line no-console
+                console.error('AI.preloadDetectors FAILED', e);
+                this._wordEntityDetector = null;
+            });
+
+        // @ts-ignore
+        this._wordEntityDetector = promise;
+
+        return promise;
+    }
+
     /**
      *
      * @param {Request} req
@@ -710,6 +790,7 @@ class Ai {
                 req.intents = [];
                 return;
             }
+
             await this._loadIntents(req, res, model);
         } else {
             req.intents = [];
@@ -734,6 +815,8 @@ class Ai {
             }
         }
 
+        await this.preloadDetectors();
+
         const texts = req.textAlternatives()
             .filter((alt) => alt.score >= this.sttScoreThreshold)
             .slice(0, this.sttMaxAlternatives);

package/src/ChatGpt.js

@@ -0,0 +1,434 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+const nodeFetch = require('node-fetch').default;
+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} RequestOptions
+ * @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 {GeneralOptions & RequestOptions} 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]
+ */
+
+/**
+ * @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<RequestOptions>} */
+        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._log = 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') }
+        ];
+    }
+
+    /**
+     *
+     * @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
+        } = {
+            ...this._options,
+            ...requestOptions
+        };
+
+        const maxTokens = Math.min(requestTokens, tokensLimit);
+
+        let body;
+
+        try {
+            body = {
+                model,
+                frequency_penalty: 0,
+                presence_penalty: presencePenalty,
+                max_tokens: maxTokens,
+                temperature
+            };
+
+            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.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._log.error('#GPT failed', {
+                    status, statusText, data, body
+                });
+                throw new Error(`Chat GPT ${status}`);
+            }
+
+            const [choice] = data.choices;
+
+            this._log.log('#GPT response', { choice, data });
+
+            return choice;
+        } catch (e) {
+            this._log.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._log.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/Processor.js

@@ -333,6 +333,7 @@ class Processor extends EventEmitter {
 
     async _preload () {
         return Promise.all([
+            Ai.ai.preloadDetectors(),
             // @ts-ignore
             this.reducer && typeof this.reducer.preload === 'function'
                 // @ts-ignore

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
+};