wingbot 3.69.8 → 3.70.0-alpha.4

package/index.js

@@ -3,8 +3,6 @@
  */
 'use strict';
 
-/** @typedef {import('./src/Processor').ProcessorOptions<Router|BuildRouter>} ProcessorOptions */
-
 const Processor = require('./src/Processor');
 const Router = require('./src/Router');
 const Request = require('./src/Request');

package/jsconfig.json

@@ -1,7 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": ["es2019", "es2020.promise", "es2020.bigint", "es2020.string"],
+        "lib": ["es2019", "es2020.promise", "es2020.bigint", "es2020.string", "dom"],
         "target": "ESNext",
         "allowSyntheticDefaultImports": true,
         "checkJs": true,
@@ -14,4 +14,4 @@
         "doc",
         "docs"
     ]
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.69.8",
+  "version": "3.70.0-alpha.4",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "type": "commonjs",
@@ -37,6 +37,7 @@
   },
   "homepage": "https://github.com/wingbot.ai/wingbot#readme",
   "devDependencies": {
+    "@types/mocha": "^10.0.10",
     "cpy-cli": "^5.0.0",
     "eslint": "^8.56.0",
     "eslint-config-airbnb": "^19.0.4",
@@ -69,4 +70,4 @@
     "axios": "^1.6.4",
     "handlebars": "^4.0.0"
   }
-}
+}

package/src/BuildRouter.js

@@ -571,8 +571,10 @@ class BuildRouter extends Router {
         };
 
         const [linksMap, nestedBlocksByStaticId] = this._createLinksMap(block);
+        // @ts-ignore
         this._linksMap = linksMap;
 
+        // @ts-ignore
         this._buildRoutes(block.routes, nestedBlocksByStaticId);
 
         this._configTs = setConfigTimestamp;
@@ -582,9 +584,10 @@ class BuildRouter extends Router {
     }
 
     /**
+     *
+     * returns {[LinksMap, BlockMap]}
      *
      * @param {Block} block
-     * @returns {[LinksMap, BlockMap]}
      */
     _createLinksMap (block) {
         const { linksMap: prevLinksMap, blocks = [] } = this._resolvedContext;

package/src/LLM.js

@@ -8,7 +8,7 @@ const { PHONE_REGEX, EMAIL_REGEX } = require('./systemEntities/regexps');
 /** @typedef {import('./Responder')} Responder */
 /** @typedef {import('./Responder').Persona} Persona */
 /** @typedef {import('./Router').BaseConfiguration} BaseConfiguration */
-/** @typedef {import('./LLMSession').LLMMessage} LLMMessage */
+/** @typedef {import('./LLMSession').LLMMessage<any>} LLMMessage */
 /** @typedef {import('./LLMSession').LLMRole} LLMRole */
 /** @typedef {import('./LLMSession')} LLMSession */
 /** @typedef {import('./transcript/transcriptFromHistory').Transcript} Transcript */

package/src/LLMMockProvider.js

@@ -38,20 +38,27 @@ class LLMMockProvider {
         if (prompt.length === 0) {
             throw new Error('Empty prompt');
         }
-        const stats = prompt.reduce((o, m) => Object.assign(o, {
-            [m.role]: (o[m.role] || 0) + 1
-        }), { system: 0, assistant: 0, user: 0 });
-
-        const statsText = JSON.stringify(stats)
-            .replace(/"/g, '');
-
-        const message = this._sequence[this._index];
-        this._index = (this._index + 1) % this._sequence.length;
+        // const stats = prompt.reduce((o, m) => Object.assign(o, {
+        //    [m.role]: (o[m.role] || 0) + 1
+        // }), { system: 0, assistant: 0, user: 0 });
+        //
+        // const statsText = JSON.stringify(stats)
+        //    .replace(/"/g, '');
+        //
+        /// / const message = this._sequence[this._index];
+        /// / this._index = (this._index + 1) % this._sequence.length;
+        //
+        // return {
+        //    role: LLM.ROLE_ASSISTANT,
+        //    finishReason: 'length',
+        // eslint-disable-next-line max-len
+        //    content: `${statsText} > ${LLMMockProvider.DEFAULT_MODEL}: ${prompt.map((m) => m.content).join(' ')}`
+        // };
 
         return {
             role: LLM.ROLE_ASSISTANT,
             finishReason: 'length',
-            content: `${statsText} > ${LLMMockProvider.DEFAULT_MODEL}: ${message}`
+            content: `${options.model || LLMMockProvider.DEFAULT_MODEL}:${prompt.map((m) => m.content).join(' ')}`
         };
     }
 

package/src/LLMSession.js

@@ -35,7 +35,7 @@ class LLMSession {
     /**
      *
      * @param {LLM} llm
-     * @param {LLMMessage[]} [chat]
+     * @param {LLMMessage<any>[]} [chat]
      * @param {SendCallback} [onSend]
      */
     constructor (llm, chat = [], onSend = () => {}) {
@@ -43,7 +43,7 @@ class LLMSession {
 
         this._onSend = onSend;
 
-        /** @type {LLMMessage[]} */
+        /** @type {LLMMessage<any>[]} */
         this._chat = chat;
 
         this._generatedIndex = null;
@@ -63,6 +63,7 @@ class LLMSession {
     }
 
     _mergeSystem () {
+        /** @type {LLMMessage<any>[]} */
         const sysMessages = [];
 
         const otherMessages = this._chat.filter((message) => {
@@ -81,7 +82,7 @@ class LLMSession {
 
         const content = sysMessages.reduce((reduced, current, i) => {
             if (i === 0) {
-                return current.content;
+                return current.content || '';
             }
             if (!reduced.match(promptRegex)) {
                 return `${reduced}\n\n${current.content}`;
@@ -189,7 +190,7 @@ class LLMSession {
     /**
      *
      * @param {LLMProviderOptions} [options={}]
-     * @returns {Promise<LLMMessage>}
+     * @returns {Promise<LLMMessage<any>>}
      */
     async generate (options = {}) {
         const result = await this._llm.generate(this, options);

package/src/Responder.js

@@ -103,6 +103,16 @@ Object.freeze(ExpectedInput);
  * @prop {string} [name]
  */
 
+/**
+ * @callback PromptGetter
+ * @param {Responder} res
+ * @returns {string|Promise<string>}
+ */
+
+/**
+ * @typedef {PromptGetter|string} PromptSource
+ */
+
 const PERSONA_DEFAULT = '_default';
 
 /**
@@ -227,7 +237,7 @@ class Responder {
 
         this.LLM_CTX_DEFAULT = 'default';
 
-        /** @type {Map<string,string[]>} */
+        /** @type {Map<string,(PromptSource|Promise<string>)[]>} */
         this._llmContext = new Map([
             [this.LLM_CTX_DEFAULT, []]
         ]);
@@ -235,36 +245,48 @@ class Responder {
 
     /**
      *
-     * @param {string} systemPrompt
+     * @param {PromptSource} systemPrompt
      * @param {string} contextType
      * @returns {this}
      */
     llmAddSystemPrompt (systemPrompt, contextType = this.LLM_CTX_DEFAULT) {
-        if (!systemPrompt || !systemPrompt.trim()) {
+        if (!systemPrompt) {
             return this;
         }
         if (!this._llmContext.has(contextType)) {
             // @todo make it array of messages / maybe keep it in a single array
             this._llmContext.set(contextType, []);
         }
-        this._llmContext.get(contextType).push(systemPrompt.trim());
+        this._llmContext.get(contextType).push(systemPrompt);
+
         return this;
     }
 
-    llmSession (contextType = this.LLM_CTX_DEFAULT) {
-        const chat = this._getSystemContentForType(contextType)
-            .map((content) => ({ role: LLM.ROLE_SYSTEM, content }));
+    async llmSession (contextType = this.LLM_CTX_DEFAULT) {
+        const system = await this._getSystemContentForType(contextType);
+
+        const chat = system.map((content) => ({ role: LLM.ROLE_SYSTEM, content }));
 
         return new LLMSession(this.llm, chat, this._llmSend.bind(this));
     }
 
+    async _replaceAsync (str, regex, asyncFn) {
+        const promises = [];
+        str.replace(regex, (full, ...args) => {
+            promises.push(asyncFn(full, ...args));
+            return full;
+        });
+        const data = await Promise.all(promises);
+        return str.replace(regex, () => data.shift());
+    }
+
     /**
      *
      * @param {string} contextType
      * @param {string[]} [callStack]
-     * @returns {string[]}
+     * @returns {Promise<string[]>}
      */
-    _getSystemContentForType (contextType, callStack = []) {
+    async _getSystemContentForType (contextType, callStack = []) {
         if (new Set(callStack).size < callStack.length) {
             throw new Error(`Circular reference detected: contextType -> ${callStack}`);
         }
@@ -273,10 +295,28 @@ class Responder {
             return [];
         }
 
-        return this._llmContext.get(contextType)
-            .map((c) => c.replace(/\$\{([a-zA-Z0-9\s]+)\}/g, (str, requestType) => this
-                ._getSystemContentForType(requestType, [...callStack, contextType])
-                .join('\n\n')).trim());
+        /** @type {Promise<string>[]} */
+        const promiseStrings = this._llmContext.get(contextType)
+            .map(async (p) => (typeof p === 'function' ? p(this) : p));
+        this._llmContext.set(contextType, promiseStrings);
+
+        const resolved = await Promise.all(
+            promiseStrings
+                .map(async (promiseString) => {
+                    const s = await promiseString;
+
+                    const replaced = await this._replaceAsync(s.trim(), /\$\{([a-zA-Z0-9\s]+)\}/g, async (str, reqType) => {
+                        const nested = await this
+                            ._getSystemContentForType(reqType, [...callStack, contextType]);
+
+                        return nested.join('\n\n');
+                    });
+
+                    return replaced.trim();
+                })
+        );
+
+        return resolved;
     }
 
     async llmSessionWithHistory (contextType = this.LLM_CTX_DEFAULT) {
@@ -286,8 +326,10 @@ class Responder {
             transcriptLength
         } = this.llm.configuration;
 
-        const systems = this._getSystemContentForType(contextType);
-        const transcript = await this.getTranscript(transcriptLength, transcriptFlag);
+        const [systems, transcript] = await Promise.all([
+            this._getSystemContentForType(contextType),
+            this.getTranscript(transcriptLength, transcriptFlag)
+        ]);
 
         const chat = [
             ...systems.map((content) => ({ role: LLM.ROLE_SYSTEM, content })),
@@ -658,12 +700,18 @@ class Responder {
         this.routePath = routePath;
     }
 
+    /**
+     * @typedef {object} MessageOptions
+     * @prop {boolean} [disableAutoTyping]
+     */
+
     /**
      * Send text as a response
      *
      * @param {string} text - text to send to user, can contain placeholders (%s)
      * @param {Object.<string,string|QuickReply>|QuickReply[]} [replies] - quick replies
      * @param {VoiceControl} [voice] - voice control data
+     * @param {MessageOptions} [options={}]
      * @returns {this}
      *
      * @example
@@ -685,7 +733,7 @@ class Responder {
      *     }
      * ]);
      */
-    text (text, replies = null, voice = null) {
+    text (text, replies = null, voice = null, options = {}) {
         const messageData = {
             message: {
                 text: this._t(text)
@@ -735,7 +783,9 @@ class Responder {
             }
         }
 
-        this._autoTypingIfEnabled(messageData.message.text);
+        if (!options.disableAutoTyping) {
+            this._autoTypingIfEnabled(messageData.message.text);
+        }
         this.send(messageData);
         return this;
     }

package/src/resolvers/contextMessage.js

@@ -0,0 +1,39 @@
+/*
+ * @author Vojtech Jedlicka
+ */
+'use strict';
+
+const Router = require('../Router');
+// eslint-disable-next-line no-unused-vars
+const Responder = require('../Responder');
+const { getLanguageText } = require('./utils');
+const compileWithState = require('../utils/compileWithState');
+
+/** @typedef {import('../BuildRouter').BotContext<any>} BotContext */
+/** @typedef {import('../Router').Resolver<any>} Resolver */
+/** @typedef {import('./utils').Translations} Translations */
+
+/**
+ *
+ * @param {object} params
+ * @param {Translations} params.context
+ * @param {string} [params.type]
+ * @param {BotContext} context
+ * @returns {Resolver}
+ */
+// eslint-disable-next-line no-unused-vars
+function contextMessage (params, context) {
+
+    return async (req, res) => {
+        res.llmAddSystemPrompt((r) => {
+            const translated = getLanguageText(params.context, req.state.lang);
+            const translatedText = Array.isArray(translated) ? translated[0] : translated;
+            const statefulPrompt = compileWithState(req, r, translatedText);
+            return statefulPrompt;
+        }, params.type);
+
+        return Router.CONTINUE;
+    };
+}
+
+module.exports = contextMessage;

package/src/resolvers/index.js

@@ -17,10 +17,12 @@ const subscribtions = require('./subscribtions');
 const setState = require('./setState');
 const expectedInput = require('./expectedInput');
 const skip = require('./skip');
+const contextMessage = require('./contextMessage');
 
 module.exports = {
     path,
     message,
+    contextMessage,
     include,
     postback,
     expected,

package/src/resolvers/message.js

@@ -270,12 +270,23 @@ function selectTranslation (resolverId, params, texts, data) {
     ];
 }
 
-/** @typedef {import('../BuildRouter').BotContext} BotContext */
-/** @typedef {import('../Router').Resolver} Resolver */
+/** @typedef {import('../BuildRouter').BotContext<any>} BotContext */
+/** @typedef {import('../Router').Resolver<any>} Resolver */
 
 /**
  *
  * @param {object} params
+ * @param {any} params.text
+ * @param {boolean} [params.hasCondition]
+ * @param {string} [params.conditionFn]
+ * @param {string} [params.conditionDesc]
+ * @param {boolean} [params.hasEditableCondition]
+ * @param {any} [params.editableCondition]
+ * @param {string} [params.mode]
+ * @param {string} [params.persist]
+ * @param {any[]} [params.replies]
+ * @param {"message" | "prompt"} [params.type]
+ * @param {string} [params.llmContextType]
  * @param {BotContext} context
  * @returns {Resolver}
  */
@@ -284,6 +295,7 @@ function message (params, context = {}) {
         // @ts-ignore
         isLastIndex, isLastMessage, linksMap, configuration, resolverId
     } = context;
+
     if (typeof params.text !== 'string' && !Array.isArray(params.text)) {
         throw new Error('Message should be a text!');
     }
@@ -294,7 +306,6 @@ function message (params, context = {}) {
         throw new Error('Replies should be an array');
     }
 
-    // compile condition
     let condition;
 
     const ret = isLastIndex ? Router.END : Router.CONTINUE;
@@ -303,10 +314,11 @@ function message (params, context = {}) {
      * @param {Request} req
      * @param {Responder} res
      */
-    return (req, res) => {
+    return async (req, res) => {
         if (condition === undefined) {
             condition = getCondition(params, context, 'Message condition');
         }
+
         if (quickReplies === undefined) {
             if (params.replies && params.replies.length > 0) {
                 quickReplies = parseReplies(params.replies, linksMap, context);
@@ -324,7 +336,8 @@ function message (params, context = {}) {
             data.lang
         );
 
-        const [text, seqState] = selectTranslation(
+        // eslint-disable-next-line prefer-const
+        let [text, seqState] = selectTranslation(
             resolverId,
             params,
             supportedText.translations,
@@ -403,6 +416,20 @@ function message (params, context = {}) {
             };
         }
 
+        if (params.type === 'prompt') {
+            const session = await res.llmSessionWithHistory(params.llmContextType);
+
+            const response = await session.systemPrompt(text)
+                .debug()
+                .generate();
+
+            // if (!response.content) {
+            //    // no response?
+            // }
+
+            text = response.content;
+        }
+
         res.text(text, sendReplies, voiceControl);
 
         if (isLastMessage && !req.actionData()._resolverTag) {

package/src/resolvers/utils.js

@@ -62,7 +62,7 @@ function isTextObjectEmpty (text) {
  * @param {Translations} translations
  * @param {string} [lang]
  * @param {boolean} [disableDefaulting] - it will try to find translation for other language
- * @returns {null|string}
+ * @returns {null|string|string[]}
  */
 function getLanguageText (translations, lang = null, disableDefaulting = false) {
     let foundText;