wingbot 3.53.5 → 3.54.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.53.5",
+  "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/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