wingbot 3.53.4 → 3.54.0

package/package.json

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

package/plugins/ai.wingbot.openai/README.md

@@ -0,0 +1 @@
+> This plugin allows you to use chatGPT

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

@@ -0,0 +1,119 @@
+/**
+ * @author wingbot.ai
+ */
+'use strict';
+
+const fetch = require('node-fetch').default;
+const compileWithState = require('../../src/utils/compileWithState');
+
+function chatgptPlugin (params) {
+
+    async function chatgpt (req, res) {
+        const content = req.text();
+
+        const token = compileWithState(req, res, params.token).trim();
+
+        // gpt-3.5-turbo-0301 gpt-3.5-turbo
+        const model = compileWithState(req, res, params.model) || 'gpt-3.5-turbo';
+
+        const system = compileWithState(req, res, params.system).trim();
+
+        // 0 - 2
+        const temperature = parseFloat(compileWithState(req, res, params.temperature).trim().replace(',', '.') || '1') || 1;
+        // 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 limit = parseInt(compileWithState(req, res, params.maxTokens).trim() || '10', 10) || 10;
+
+        const user = `${req.pageId}|${req.senderId}`;
+
+        const systemAfter = compileWithState(req, res, params.systemAfter).trim();
+
+        let body;
+
+        try {
+            res.typingOn();
+
+            body = {
+                model,
+                frequency_penalty: 0,
+                presence_penalty: presence,
+                max_tokens: maxTokens,
+                temperature,
+                user
+            };
+
+            const ts = await res.getTranscript(limit);
+
+            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 response = await useFetch('https://api.openai.com/v1/chat/completions', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${token}`
+                },
+                body: JSON.stringify(body)
+            });
+
+            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 });
+                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 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);
+                    }
+
+                    filtered
+                        .forEach((t) => res.text(t.trim()));
+
+                    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');
+        }
+
+    }
+
+    return chatgpt;
+}
+
+module.exports = chatgptPlugin;

package/plugins/plugins.json

@@ -484,6 +484,86 @@
             ],
             "items": [
             ]
+        },
+        {
+            "id": "ai.wingbot.openai",
+            "name": "OpenAI - Chat",
+            "description": "Use within fallback to attach ChatGPT to your chatbot",
+            "availableSince": 3.54,
+            "editable": false,
+            "isFactory": true,
+            "category": "conversation",
+            "inputs": [
+                {
+                    "name": "token",
+                    "label": "API Key",
+                    "type": "text",
+                    "validations": [
+                        { "type": "regexp", "value": "^.+$", "message": "the token should be filled" }
+                    ]
+                },
+                {
+                    "type": "select",
+                    "name": "model",
+                    "label": "Chat GPT model",
+                    "options": [
+                        { "value": "gpt-3.5-turbo", "label": "gpt-3.5-turbo" },
+                        { "value": "gpt-3.5-turbo-0301", "label": "gpt-3.5-turbo-0301" }
+                    ]
+                },
+                {
+                    "type": "textarea",
+                    "name": "system",
+                    "label": "Initial preset message (system)"
+                },
+                {
+                    "type": "text",
+                    "name": "temperature",
+                    "label": "Temperature: 0.0 - 2.0 (1.0) - randomness of answers",
+                    "validations": [
+                        {
+                            "type": "regexp",
+                            "value": "^[0-9]*([.,][0-9]+)?$",
+                            "message": "Temperature should be a valid float number"
+                        }
+                    ]
+                },
+                {
+                    "type": "text",
+                    "name": "presence",
+                    "label": "Presence: -2.0 - 2.0 (0.0) - likelihood to talk about new topics",
+                    "validations": [
+                        {
+                            "type": "regexp",
+                            "value": "^-?[0-9]*([.,][0-9]+)?$",
+                            "message": "Presence should be a valid float number"
+                        }
+                    ]
+                },
+                {
+                    "type": "text",
+                    "name": "maxTokens",
+                    "label": "Max Tokens: 0 - 4096 (512) - max. number of returned tokens",
+                    "validations": [
+                        {
+                            "type": "regexp",
+                            "value": "^[0-9]*$",
+                            "message": "Max tokens should be a valid number"
+                        }
+                    ]
+                },
+                {
+                    "type": "textarea",
+                    "name": "systemAfter",
+                    "label": "Current message (system)"
+                }
+            ],
+            "items": [
+                {
+                    "id": "fallback",
+                    "description": "If API call fails"
+                }
+            ]
         }
     ],
     "categories": [

package/src/AiMatching.js

@@ -23,6 +23,16 @@ const FULL_EMOJI_REGEX = /^#((?:[\u2600-\u27bf].?|(?:\ud83c[\udde6-\uddff]){2}|[
 const HAS_CLOSING_HASH = /^#(.+)#$/;
 const ENTITY_REGEX = /^@([^=><!?]+)(\?)?([!=><]{1,2})?([^=><!]+)?$/i;
 
+/**
+ * @typedef {object} EntityMatchingResult
+ * @prop {number} score
+ * @prop {number} handicap
+ * @prop {number} fromState
+ * @prop {number} minScore
+ * @prop {number} metl
+ * @prop {Entity[]} matched
+ */
+
 /**
  * RegExp to test a string for a ISO 8601 Date spec
  *  YYYY
@@ -449,6 +459,7 @@ class AiMatching {
 
         const noIntentHandicap = req.intents.length === 0 ? 0 : this.redundantIntentHandicap;
         const regexpScore = this._matchRegexp(req, regexps, noIntentHandicap);
+        const textLength = req.text().trim().length;
 
         if (regexpScore !== 0 || (intents.length === 0 && regexps.length === 0)) {
 
@@ -477,8 +488,11 @@ class AiMatching {
                 useState = stateData(req);
             }
 
-            const { score, handicap, matched } = this
+            const {
+                score, handicap, matched, metl
+            } = this
                 ._entityMatching(
+                    textLength,
                     entities,
                     reqEntities,
                     useState
@@ -499,30 +513,19 @@ class AiMatching {
                 ? score - noIntentHandicap
                 : (regexpScore + score) / 2;
 
-            const matchedEntitiesTextLength = matched.reduce((tot, entity) => (
-                typeof entity.end === 'number' && typeof entity.start === 'number' && tot !== null
-                    ? (tot + (entity.end - entity.start))
-                    : null
-            ), 0);
-            const textLength = req.text().trim().length;
-
-            const useHandicap = textLength <= matchedEntitiesTextLength
-                ? Math.max(-this.redundantEntityHandicap, baseScore - 1)
-                : handicap;
-
-            let finalScore = (baseScore - useHandicap)
+            let finalScore = (baseScore - handicap)
                 * (this.multiMatchGain ** countOfAdditionalItems);
 
-            if (matchedEntitiesTextLength && textLength) {
+            if (metl && textLength) {
                 const remainingScore = Math.max(0, Math.min(1, finalScore) - (
                     this._ai.confidence + this.redundantEntityHandicap
                 ));
 
-                const remainingTextLen = (textLength - matchedEntitiesTextLength);
+                const remainingTextLen = (textLength - metl);
                 const minus = (remainingTextLen / textLength) * remainingScore;
 
                 // eslint-disable-next-line max-len,object-curly-newline
-                // console.log({ minus, matchedEntitiesTextLength, textLength, remainingScore })
+                // console.log({ minus, metl, textLength, remainingScore })
 
                 finalScore -= minus;
             }
@@ -552,7 +555,14 @@ class AiMatching {
                 let max = total;
                 for (const requestIntent of req.intents) {
                     const { score, entities: matchedEntities } = this
-                        ._intentMatchingScore(wanted, requestIntent, entities, req, stateless);
+                        ._intentMatchingScore(
+                            textLength,
+                            wanted,
+                            requestIntent,
+                            entities,
+                            req,
+                            stateless
+                        );
 
                     if (score > max) {
                         max = score;
@@ -579,6 +589,7 @@ class AiMatching {
     /**
      *
      * @private
+     * @param {number} textLength
      * @param {string} wantedIntent
      * @param {Intent} requestIntent
      * @param {EntityExpression[]} wantedEntities
@@ -586,7 +597,14 @@ class AiMatching {
      * @param {boolean} stateless
      * @returns {{score:number,entities:Entity[]}}
      */
-    _intentMatchingScore (wantedIntent, requestIntent, wantedEntities, req, stateless = false) {
+    _intentMatchingScore (
+        textLength,
+        wantedIntent,
+        requestIntent,
+        wantedEntities,
+        req,
+        stateless = false
+    ) {
         if (wantedIntent !== requestIntent.intent) {
             return { score: 0, entities: [] };
         }
@@ -604,12 +622,14 @@ class AiMatching {
             score: entitiesScore, handicap, matched, minScore, fromState
         } = this
             ._entityMatching(
+                textLength,
                 wantedEntities,
                 useEntities,
                 stateless ? {} : req.state,
                 requestIntent.entities
                     ? (x) => Math.atan((x - 0.76) * 40) / Math.atan((1 - 0.76) * 40)
-                    : (x) => x
+                    : (x) => x,
+                req.entities
             );
 
         // eslint-disable-next-line max-len,object-curly-newline
@@ -639,13 +659,23 @@ class AiMatching {
     /**
      *
      * @private
+     * @param {number} textLen
      * @param {EntityExpression[]} wantedEntities
      * @param {Entity[]} requestEntities
      * @param {object} [requestState]
      * @param {Function} [scoreFn]
-     * @returns {{score:number,handicap:number, matched:Entity[],minScore:number,fromState:number}}
+     * @param {Entity[]} allEntities
+     *
+     * @returns {EntityMatchingResult}
      */
-    _entityMatching (wantedEntities, requestEntities = [], requestState = {}, scoreFn = (x) => x) {
+    _entityMatching (
+        textLen,
+        wantedEntities,
+        requestEntities = [],
+        requestState = {},
+        scoreFn = (x) => x,
+        allEntities = requestEntities
+    ) {
         const occurences = new Map();
 
         const matched = [];
@@ -653,6 +683,7 @@ class AiMatching {
         let sum = 0;
         let minScore = 1;
         let fromState = 0;
+        let metl = 0;
 
         for (const wanted of wantedEntities) {
             const usedIndexes = occurences.has(wanted.entity)
@@ -705,7 +736,7 @@ class AiMatching {
 
             if (!matching && (!wanted.optional || entityExists)) {
                 return {
-                    score: 0, handicap: 0, matched: [], minScore, fromState
+                    score: 0, handicap: 0, matched: [], minScore, fromState, metl
                 };
             }
 
@@ -731,6 +762,10 @@ class AiMatching {
             }
 
             if (requestEntity) {
+                if (typeof requestEntity.end === 'number' && typeof requestEntity.start === 'number') {
+                    metl += requestEntity.end - requestEntity.start;
+                }
+
                 matched.push(requestEntity);
                 sum += scoreFn(requestEntity.score);
                 if (index !== -1) {
@@ -747,16 +782,37 @@ class AiMatching {
             }
         }
 
+        const withCoveringEntity = textLen && textLen <= metl;
+
         // eslint-disable-next-line max-len
-        // console.log({ wantedEntities, sum, handicap, rl: requestEntities.length, ml: matched.length });
+        // console.log({ metl, withCoveringEntity, wantedEntities, sum, handicap, rl: requestEntities.length, ml: matched.length });
+
+        if (withCoveringEntity) {
+            handicap -= this.redundantEntityHandicap;
+        } else {
+            const otherEntitiesTextLen = allEntities
+                .filter((re) => !matched.some((e) => e.entity === re.entity))
+                .reduce((tot, entity) => (
+                    typeof entity.end === 'number' && typeof entity.start === 'number'
+                        ? (tot + (entity.end - entity.start))
+                        : 0
+                ), 0);
+
+            const coveringHandicap = textLen && otherEntitiesTextLen >= textLen
+                ? 1
+                : 0;
 
-        // @todo - neni mozne, by doslo k negativnimu handicapu
-        handicap += (requestEntities.length + fromState - matched.length)
-            * this.redundantEntityHandicap;
+            handicap += (requestEntities.length + fromState - matched.length + coveringHandicap)
+                * this.redundantEntityHandicap;
+
+            // eslint-disable-next-line max-len
+            // console.log({ requestEntities, matched, handicap, coveringHandicap, otherEntitiesTextLen });
+
+        }
         const score = matched.length === 0 ? 0 : sum / matched.length;
 
         return {
-            score, handicap, matched, minScore, fromState
+            score, handicap, matched, minScore, fromState, metl
         };
     }
 

package/src/Processor.js

@@ -646,7 +646,8 @@ class Processor extends EventEmitter {
             const options = {
                 ...this.options,
                 state: Object.freeze({ ...state }),
-                features
+                features,
+                pageId
             };
 
             res = new Responder(senderId, messageSender, token, options, responderData);

package/src/Responder.js

@@ -16,6 +16,7 @@ const {
     FEATURE_SSML,
     FEATURE_PHRASES
 } = require('./features');
+const transcriptFromHistory = require('./transcript/transcriptFromHistory');
 
 const TYPE_RESPONSE = 'RESPONSE';
 const TYPE_UPDATE = 'UPDATE';
@@ -26,6 +27,7 @@ const EXCEPTION_HOPCOUNT_THRESHOLD = 5;
 /** @typedef {import('./ReturnSender').UploadResult} UploadResult */
 /** @typedef {import('./analytics/consts').TrackingCategory} TrackingCategory */
 /** @typedef {import('./analytics/consts').TrackingType} TrackingType */
+/** @typedef {import('./transcript/transcriptFromHistory').Transcript} Transcript */
 
 /**
  * @enum {string} ExpectedInput
@@ -89,6 +91,7 @@ class Responder {
     constructor (senderId, messageSender, token = null, options = {}, data = {}) {
         this._messageSender = messageSender;
         this._senderId = senderId;
+        this._pageId = options.pageId;
         this.token = token;
 
         /**
@@ -178,6 +181,33 @@ class Responder {
         this._recipient = { id: senderId };
 
         this._textResponses = [];
+
+        this._typingSent = false;
+    }
+
+    /**
+     *
+     * Returns current conversation transcript
+     *
+     * @param {number} [limit]
+     * @returns {Promise<Transcript[]>}
+     */
+    async getTranscript (limit = 10) {
+        const { chatLogStorage } = this._messageSender;
+        if (!chatLogStorage) {
+            return [];
+        }
+        const transcript = await transcriptFromHistory(
+            chatLogStorage,
+            this._senderId,
+            this._pageId,
+            limit
+        );
+        const { responseTexts = [] } = chatLogStorage;
+        transcript.push(...responseTexts.map((text) => ({
+            fromBot: true, text
+        })));
+        return transcript;
     }
 
     /**
@@ -287,6 +317,7 @@ class Responder {
             });
         }
         this.startedOutput = true;
+        this._typingSent = data.sender_action === 'typing_on';
         this._messageSender.send(data);
         return this;
     }
@@ -979,10 +1010,11 @@ class Responder {
     /**
      * Sends "typing..." information
      *
+     * @param {boolean} [force] - send even if was recently sent
      * @returns {this}
      */
-    typingOn () {
-        return this._senderAction('typing_on');
+    typingOn (force = false) {
+        return this._senderAction('typing_on', force);
     }
 
     /**
@@ -1243,7 +1275,10 @@ class Responder {
         return this._textResponses;
     }
 
-    _senderAction (action) {
+    _senderAction (action, force = false) {
+        if (action === 'typing_on' && this._typingSent && !force) {
+            return this;
+        }
         const messageData = {
             sender_action: action
         };

package/src/ReturnSender.js

@@ -12,10 +12,21 @@ const extractText = require('./transcript/extractText');
 /** @typedef {import('./Responder')} Responder */
 /** @typedef {import('./Processor').TrackingObject} TrackingObject */
 
+/**
+ * @callback GetInteractions
+ * @param {string} senderId
+ * @param {string} pageId
+ * @param {number} [limit]
+ * @param {number} [endAt] - iterate backwards to history
+ * @param {number} [startAt] - iterate forward to last interaction
+ * @returns {Promise<object[]>}
+ */
+
 /**
  * @typedef {object} ChatLogStorage
- * @property {Function} log
- * @property {Function} error
+ * @prop {Function} log
+ * @prop {Function} error
+ * @prop {GetInteractions} [getInteractions]
  */
 
 /**
@@ -165,6 +176,13 @@ class ReturnSender {
             .filter((t) => t && `${t}`.trim());
     }
 
+    /**
+     * @returns {ChatLogStorage}
+     */
+    get chatLogStorage () {
+        return this._logger;
+    }
+
     _gotAnotherEvent () {
         if (this._gotAnotherEventDefer) {
             this._gotAnotherEventDefer();

package/src/transcript/transcriptFromHistory.js

@@ -33,6 +33,9 @@ const extractText = require('./extractText');
  * @returns {Promise<Transcript[]>}
  */
 async function transcriptFromHistory (chatLogStorage, senderId, pageId, limit = 20) {
+    if (typeof chatLogStorage.getInteractions !== 'function') {
+        return [];
+    }
     const data = await chatLogStorage.getInteractions(senderId, pageId, limit);
 
     return data