wingbot 3.69.7 → 3.69.8

package/jsconfig.json

@@ -1,8 +1,8 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": ["es6"],
-        "target": "es2019",
+        "lib": ["es2019", "es2020.promise", "es2020.bigint", "es2020.string"],
+        "target": "ESNext",
         "allowSyntheticDefaultImports": true,
         "checkJs": true,
         "resolveJsonModule": true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.69.7",
+  "version": "3.69.8",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "type": "commonjs",
@@ -61,7 +61,7 @@
     "graphql": "^16.8.1",
     "jsonwebtoken": "^9.0.2",
     "node-fetch": "^2.6.7",
-    "path-to-regexp": "^6.2.1",
+    "path-to-regexp": "^6.3.0",
     "uuid": "^9.0.1",
     "webalize": "^0.1.0"
   },

package/src/BuildRouter.js

@@ -77,6 +77,10 @@ const PLUGIN_RESOLVER_NAME = 'botbuild.customCode';
  * @typedef {Map<string|number,string>} LinksMap
  */
 
+/**
+ * @typedef {Map<string|number, Block>} BlockMap
+ */
+
 /** @type {TransformedRoute} */
 const DUMMY_ROUTE = { id: 0, path: null, resolvers: [] };
 
@@ -136,6 +140,7 @@ const DUMMY_ROUTE = { id: 0, path: null, resolvers: [] };
 
 /**
  * @typedef {object} BotContextExtention
+ * @prop {BlockMap} [nestedBlocksByStaticId]
  * @prop {LinksMap} [linksMap]
  * @prop {boolean} [isLastIndex]
  * @prop {boolean} [isLastMessage]
@@ -565,11 +570,10 @@ class BuildRouter extends Router {
             ...this._resolvedContext, blockName, blockType, isRoot, staticBlockId, BuildRouter
         };
 
-        this._linksMap = this._createLinksMap(block);
-
-        this._setExpectedFromResponderRoutes(block.routes);
+        const [linksMap, nestedBlocksByStaticId] = this._createLinksMap(block);
+        this._linksMap = linksMap;
 
-        this._buildRoutes(block.routes);
+        this._buildRoutes(block.routes, nestedBlocksByStaticId);
 
         this._configTs = setConfigTimestamp;
 
@@ -577,74 +581,78 @@ class BuildRouter extends Router {
         this.emit('rebuild');
     }
 
-    _setExpectedFromResponderRoutes (routes) {
-        const set = new Set();
-
-        routes.forEach((route) => {
-            if (!route.isResponder) {
-                return;
-            }
-
-            // create the pseudopath ant set to set to corresponding route
-            const referredRoutePath = this._linksMap.get(route.respondsToRouteId);
-
-            if (!referredRoutePath) {
-                return;
-            }
-
-            const expectedPath = `${referredRoutePath}_responder`
-                .replace(/^\//, '');
-
-            Object.assign(route, { path: expectedPath });
-
-            // set expectedPath to referredRoute
-
-            if (set.has(route.respondsToRouteId)) {
-                return;
-            }
-            set.add(route.respondsToRouteId);
-
-            const referredRoute = routes.find((r) => r.id === route.respondsToRouteId);
-
-            Object.assign(referredRoute, { expectedPath });
-        });
-    }
-
     /**
      *
      * @param {Block} block
-     * @returns {LinksMap}
+     * @returns {[LinksMap, BlockMap]}
      */
     _createLinksMap (block) {
+        const { linksMap: prevLinksMap, blocks = [] } = this._resolvedContext;
+
         /** @type {LinksMap} */
         const linksMap = new Map();
 
+        if (prevLinksMap) {
+            for (const [from, to] of prevLinksMap.entries()) {
+                linksMap.set(from, `../${to}`); //  this._joinPaths('..', to)
+            }
+        }
+
+        const expectedFromResponders = new Set();
+
+        const blocksById = new Map();
+
         block.routes
-            .filter((route) => !route.isResponder)
-            .forEach((route) => linksMap.set(route.id, route.path));
+            .forEach((route) => {
+                if (!route.isResponder) {
+                    linksMap.set(route.id, route.path);
+                }
+                blocksById.set(route.id, route);
+            });
 
-        const { linksMap: prevLinksMap } = this._resolvedContext;
+        let { nestedBlocksByStaticId } = this._resolvedContext;
+        if (!nestedBlocksByStaticId) {
+            nestedBlocksByStaticId = new Map();
 
-        if (prevLinksMap) {
-            for (const [from, to] of prevLinksMap.entries()) {
-                if (!linksMap.has(from)) {
-                    linksMap.set(from, this._joinPaths('..', to));
+            blocks.forEach((b) => {
+                if (b.staticBlockId && !b.disabled) {
+                    nestedBlocksByStaticId.set(b.staticBlockId, b);
                 }
-            }
+            });
+
+            Object.assign(this._resolvedContext, { nestedBlocksByStaticId });
         }
 
         block.routes.forEach((route) => {
-            const enabledNestedBlock = this._getBlockById(this._getIncludedBlockId(route));
-            if (!enabledNestedBlock) {
-                return;
+            const enabledNestedBlock = nestedBlocksByStaticId.get(this._getIncludedBlockId(route));
+            if (enabledNestedBlock) {
+                const routeConfig = this._getRouteConfig(route);
+                if (this._enabledByRouteConfig(routeConfig)) {
+                    this._findEntryPointsInResolver(linksMap, enabledNestedBlock, route);
+                }
             }
-            const routeConfig = this._getRouteConfig(route);
-            if (this._enabledByRouteConfig(routeConfig)) {
-                this._findEntryPointsInResolver(linksMap, enabledNestedBlock, route);
+
+            if (route.isResponder) {
+                // create the pseudopath ant set to set to corresponding route
+                const referredRoutePath = linksMap.get(route.respondsToRouteId);
+
+                if (referredRoutePath) {
+                    const expectedPath = `${referredRoutePath}_responder`
+                        .replace(/^\//, '');
+
+                    Object.assign(route, { path: expectedPath });
+
+                    if (!expectedFromResponders.has(route.respondsToRouteId)) {
+                        expectedFromResponders.add(route.respondsToRouteId);
+
+                        const referredRoute = blocksById.get(route.respondsToRouteId);
+                        Object.assign(referredRoute, { expectedPath });
+                    }
+                }
             }
         });
 
-        return linksMap;
+        return [linksMap, nestedBlocksByStaticId];
     }
 
     /**
@@ -682,24 +690,6 @@ class BuildRouter extends Router {
             : null;
     }
 
-    /**
-     *
-     * @param {string} staticBlockId
-     * @returns {Block|null}
-     */
-    _getBlockById (staticBlockId) {
-        if (!staticBlockId) {
-            return null;
-        }
-        const nestedBlock = (this._resolvedContext.blocks || [])
-            .find((b) => b.staticBlockId === staticBlockId);
-
-        if (!nestedBlock || nestedBlock.disabled) {
-            return null;
-        }
-        return nestedBlock;
-    }
-
     /**
      *
      * @param {TransformedRoute} route
@@ -811,8 +801,9 @@ class BuildRouter extends Router {
     /**
      *
      * @param {TransformedRoute[]} routes
+     * @param {BlockMap} nestedBlocksByStaticId
      */
-    _buildRoutes (routes) {
+    _buildRoutes (routes, nestedBlocksByStaticId) {
         routes.forEach((route, i) => {
             const routeConfig = this._getRouteConfig(route);
 
@@ -821,7 +812,7 @@ class BuildRouter extends Router {
             }
 
             const includedBlockId = this._getIncludedBlockId(route);
-            const nestedBlock = this._getBlockById(includedBlockId);
+            const nestedBlock = nestedBlocksByStaticId.get(includedBlockId);
 
             if (includedBlockId && (!nestedBlock || !this._enabledByRouteConfig(routeConfig))) {
                 return;
@@ -882,9 +873,10 @@ class BuildRouter extends Router {
      * @param {Resolver[]} resolvers
      * @param {TransformedRoute} [route]
      * @param {BuildInfo} [buildInfo]
+     * @param {BlockMap} [nestedBlocksByStaticId=null]
      * @returns {Middleware<S,C>[]}
      */
-    buildResolvers (resolvers, route = DUMMY_ROUTE, buildInfo = {}) {
+    buildResolvers (resolvers, route = DUMMY_ROUTE, buildInfo = {}, nestedBlocksByStaticId = null) {
         const {
             path: ctxPath, isFallback, isResponder, expectedPath, id
         } = route;
@@ -911,7 +903,8 @@ class BuildRouter extends Router {
                 expectedPath,
                 routeId: id,
                 configuration,
-                resolverId: resolver.id
+                resolverId: resolver.id,
+                nestedBlocksByStaticId
             };
 
             const resFn = this._resolverFactory(resolver, context, buildInfo);

package/src/ChatGpt.js

@@ -6,11 +6,14 @@
 const nodeFetch = require('node-fetch').default;
 const util = require('util');
 const { PHONE_REGEX, EMAIL_REGEX } = require('./systemEntities/regexps');
+const LLM = require('./LLM');
 
 /** @typedef {import('node-fetch').default} Fetch */
 /** @typedef {import('./Request')} Request */
 /** @typedef {import('./Responder')} Responder */
 /** @typedef {import('./Responder').QuickReply} QuickReply */
+/** @typedef {import('./LLM').LLMMessage} LLMMessage */
+/** @typedef {import('./LLM').LLMProviderOptions} LLMProviderOptions */
 
 /**
  * @typedef {object} Transcript
@@ -59,7 +62,7 @@ const { PHONE_REGEX, EMAIL_REGEX } = require('./systemEntities/regexps');
 
 /**
  * @typedef {object} ChatGPTChoice
- * @prop {'stop'|'length'|'function_call'|'content_filter'|null} finish_reason
+ * @prop {'stop'|'length'|'tool_calls'|'content_filter'|null} finish_reason
  * @prop {number} index
  * @prop {Message} message
  */
@@ -237,16 +240,31 @@ class ChatGpt {
         }));
     }
 
+    /**
+     * @param {LLMMessage[]} prompt
+     * @param {LLMProviderOptions} [options]
+     * @returns {Promise<LLMMessage>}
+     */
+    async requestChat (prompt, options) {
+
+        const choice = await this._request(prompt, options);
+
+        const { finish_reason: finishReason, message } = choice;
+
+        return {
+            finishReason,
+            ...message
+        };
+    }
+
     /**
      *
-     * @param {string} content
-     * @param {string} [system]
-     * @param {Transcript[]} [transcript]
-     * @param {RequestOptions} [requestOptions]
-     * @param {string|Request} [user]
+     * @param {LLMMessage[]} chat
+     * @param {RequestOptions} requestOptions
+     * @param {string} user
      * @returns {Promise<ChatGPTChoice>}
      */
-    async request (content, system = null, transcript = [], requestOptions = {}, user = null) {
+    async _request (chat, requestOptions, user = null) {
         const {
             requestTokens,
             tokensLimit,
@@ -259,50 +277,51 @@ class ChatGpt {
             ...requestOptions
         };
 
+        let messages = chat;
         const maxTokens = Math.min(requestTokens, tokensLimit);
 
         let body;
-
         try {
+            let lastUserIndex = 0;
+            let totalTokens = messages
+                .reduce((total, m, i) => {
+                    if (m.role === LLM.ROLE_USER) {
+                        lastUserIndex = i;
+                    }
+                    return (m.content ? 0 : m.content.length) + total;
+                }, 0);
+
+            if (totalTokens > tokensLimit) {
+                messages = messages.filter((m, i) => {
+                    if (m.role === LLM.ROLE_SYSTEM
+                        || i >= lastUserIndex
+                        || totalTokens <= tokensLimit
+                        || !m.content) {
+
+                        return true;
+                    }
+                    totalTokens -= m.content.length;
+                    return false;
+                });
+            }
+
             body = {
                 model,
                 frequency_penalty: 0,
                 presence_penalty: presencePenalty,
                 max_tokens: maxTokens,
                 temperature,
-                ...(functions.length ? { functions } : {})
+                messages
             };
 
-            if (typeof user === 'string') {
+            if (user) {
                 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);
-                }
+            if (functions.length) {
+                Object.assign(body, { functions });
             }
 
-            /** @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);
@@ -342,6 +361,37 @@ class ChatGpt {
         }
     }
 
+    /**
+     *
+     * @deprecated
+     * @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) {
+
+        /** @type {Message[]} */
+        const messages = [
+            ...(system ? [{ role: 'system', content: system }] : []),
+            ...transcript.map((t) => ({ role: t.fromBot ? 'assistant' : 'user', content: t.text })),
+            { role: 'user', content }
+        ];
+
+        let useUser;
+        if (typeof user === 'string') {
+            useUser = user;
+        } else if (user) {
+            useUser = `${user.pageId}|${user.senderId}`;
+        } else if (this._defaultUser) {
+            useUser = this._defaultUser;
+        }
+
+        return this._request(messages, requestOptions, useUser);
+    }
+
     /**
      *
      * @param {ChatGPTChoice} choice

package/src/LLM.js

@@ -0,0 +1,160 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+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').LLMRole} LLMRole */
+/** @typedef {import('./LLMSession')} LLMSession */
+/** @typedef {import('./transcript/transcriptFromHistory').Transcript} Transcript */
+
+/**
+ * @callback LLMChatProviderPrompt
+ * @param {LLMMessage[]} prompt
+ * @param {LLMProviderOptions} [options]
+ * @returns {Promise<LLMMessage>}
+ */
+
+/**
+ * @typedef {object} LLMProviderOptions
+ * @prop {string} [model]
+ */
+
+/**
+ * @typedef {object} LLMChatProvider
+ * @prop {LLMChatProviderPrompt} requestChat
+ */
+
+/** @typedef {import('node-fetch').default} Fetch */
+
+/**
+ * @typedef {object} LLMConfiguration
+ * @prop {LLMChatProvider} provider
+ * @prop {string} [model]
+ * @prop {number} [transcriptLength=-5]
+ * @prop {'gpt'|string} [transcriptFlag]
+ * @prop {boolean} [transcriptAnonymize]
+ * @prop {Persona|string|null} [persona]
+ */
+
+/**
+ * @typedef {object} AnonymizeRegexp
+ * @prop {string} [replacement]
+ * @prop {RegExp} regex
+ */
+
+/**
+ * @class LLM
+ */
+class LLM {
+
+    /** @type {LLMRole} */
+    static ROLE_USER = 'user';
+
+    /** @type {LLMRole} */
+    static ROLE_ASSISTANT = 'assistant';
+
+    /** @type {LLMRole} */
+    static ROLE_SYSTEM = 'system';
+
+    static GPT_FLAG = 'gpt';
+
+    /** @type {AnonymizeRegexp[]} */
+    static anonymizeRegexps = [
+        { replacement: '@PHONE', regex: new RegExp(PHONE_REGEX.source, 'g') },
+        { replacement: '@EMAIL', regex: new RegExp(EMAIL_REGEX.source, 'g') }
+    ];
+
+    /**
+     *
+     * @param {LLMConfiguration} configuration
+     */
+    constructor (configuration) {
+        const { provider, ...rest } = configuration;
+
+        this._configuration = {
+            transcriptFlag: 'gpt',
+            transcriptLength: 5,
+            provider: null,
+            ...rest
+        };
+
+        /** @type {LLMChatProvider} */
+        this._provider = provider;
+    }
+
+    /**
+     * @returns {Omit<LLMConfiguration, 'provider'>}
+     */
+    get configuration () {
+        return this._configuration;
+    }
+
+    /**
+     *
+     * @param {Transcript[]} chat
+     * @param {boolean} [transcriptAnonymize]
+     * @returns {LLMMessage[]}
+     */
+    static anonymizeTranscript (chat, transcriptAnonymize) {
+        return chat.map((c) => ({
+            role: c.fromBot ? LLM.ROLE_ASSISTANT : LLM.ROLE_USER,
+            content: transcriptAnonymize
+                ? LLM.anonymizeRegexps
+                    .reduce((text, { replacement, regex }) => {
+                        const replaced = text.replace(regex, replacement);
+                        return replaced;
+                    }, c.text)
+                : c.text
+        }));
+    }
+
+    /**
+     *
+     * @param {LLMSession} session
+     * @param {LLMProviderOptions} [options={}]
+     * @returns {Promise<LLMMessage>}
+     */
+    async generate (session, options = {}) {
+        /** @type {LLMProviderOptions} */
+        const opts = {
+            model: this._configuration.model,
+            ...options
+        };
+
+        const prompt = session.toArray();
+        const result = await this._provider.requestChat(prompt, opts);
+
+        return result;
+    }
+
+    /**
+     *
+     * @param {LLMMessage} result
+     * @returns {LLMMessage[]}
+     */
+    static toMessages (result) {
+        let filtered = result.content
+            .replace(/\n\n+/g, '\n')
+            .split(/\n+(?!-)/g)
+            .map((t) => t.trim())
+            .filter((t) => !!t);
+
+        if (result.finishReason === 'length' && filtered.length <= 0) {
+            filtered = filtered.slice(0, filtered.length - 1);
+        }
+
+        return filtered.map((content) => ({
+            content,
+            role: result.role
+        }));
+    }
+
+}
+
+module.exports = LLM;

package/src/LLMMockProvider.js

@@ -0,0 +1,60 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+const LLM = require('./LLM');
+
+/** @typedef {import('./LLM').LLMChatProvider} LLMChatProvider */
+/** @typedef {import('./LLM').LLMMessage} LLMMessage */
+/** @typedef {import('./LLM').LLMProviderOptions} LLMProviderOptions */
+
+/**
+ * @class LLMMockProvider
+ * @implements {LLMChatProvider}
+ */
+class LLMMockProvider {
+
+    static DEFAULT_MODEL = 'mockmodel';
+
+    constructor () {
+        this._index = 0;
+        this._sequence = [
+            'lorem',
+            'ipsum',
+            'dolor',
+            'sit',
+            'amet'
+        ];
+    }
+
+    /**
+     * @param {LLMMessage[]} prompt
+     * @param {LLMProviderOptions} [options]
+     * @returns {Promise<LLMMessage>}
+     */
+    // eslint-disable-next-line no-unused-vars
+    async requestChat (prompt, options) {
+        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;
+
+        return {
+            role: LLM.ROLE_ASSISTANT,
+            finishReason: 'length',
+            content: `${statsText} > ${LLMMockProvider.DEFAULT_MODEL}: ${message}`
+        };
+    }
+
+}
+
+module.exports = LLMMockProvider;

package/src/LLMSession.js

@@ -0,0 +1,227 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+const LLM = require('./LLM');
+
+/** @typedef {import('./Responder').QuickReply} QuickReply */
+/** @typedef {'user'|'assistant'} LLMChatRole */
+/** @typedef {'system'} LLMSystemRole */
+/** @typedef {LLMChatRole|LLMSystemRole|string} LLMRole */
+/** @typedef {import('./LLM').LLMProviderOptions} LLMProviderOptions */
+
+/** @typedef {'stop'|'length'|'tool_calls'|'content_filter'} LLMFinishReason */
+
+/**
+ * @template {LLMRole} [R=LLMRole]
+ * @typedef {object} LLMMessage
+ * @prop {R} role
+ * @prop {string} content
+ * @prop {LLMFinishReason} [finishReason]
+ */
+
+/**
+ * @callback SendCallback
+ * @param {LLMMessage[]} messages
+ * @param {QuickReply[]} quickReplies
+ */
+
+/**
+ * @class LLMSession
+ */
+class LLMSession {
+
+    /**
+     *
+     * @param {LLM} llm
+     * @param {LLMMessage[]} [chat]
+     * @param {SendCallback} [onSend]
+     */
+    constructor (llm, chat = [], onSend = () => {}) {
+        this._llm = llm;
+
+        this._onSend = onSend;
+
+        /** @type {LLMMessage[]} */
+        this._chat = chat;
+
+        this._generatedIndex = null;
+
+        this._sort();
+    }
+
+    _sort (what = this._chat) {
+        what.sort((a, z) => {
+            if (a.role === z.role
+                || (a.role !== LLM.ROLE_SYSTEM && z.role !== LLM.ROLE_SYSTEM)) {
+                return 0;
+            }
+            return a.role === LLM.ROLE_SYSTEM ? -1 : 1;
+        });
+        return what;
+    }
+
+    _mergeSystem () {
+        const sysMessages = [];
+
+        const otherMessages = this._chat.filter((message) => {
+            if (message.role !== LLM.ROLE_SYSTEM) {
+                return true;
+            }
+            sysMessages.push(message);
+            return false;
+        });
+
+        if (sysMessages.length === 0) {
+            return otherMessages;
+        }
+
+        const promptRegex = /\$\{prompt\(\)\}/g;
+
+        const content = sysMessages.reduce((reduced, current, i) => {
+            if (i === 0) {
+                return current.content;
+            }
+            if (!reduced.match(promptRegex)) {
+                return `${reduced}\n\n${current.content}`;
+            }
+            return reduced.replace(promptRegex, current.content).trim();
+        }, '')
+            .replace(promptRegex, '')
+            .trim();
+
+        return [
+            {
+                role: LLM.ROLE_SYSTEM, content
+            },
+            ...otherMessages
+        ];
+    }
+
+    /**
+     * @returns {LLMMessage[]}
+     */
+    toArray () {
+        return this._mergeSystem();
+    }
+
+    /**
+     *
+     * @param {LLMMessage} msg
+     * @returns {string}
+     */
+    _msgPrefix (msg) {
+        switch (msg.role) {
+            case LLM.ROLE_SYSTEM:
+                return '-';
+            case LLM.ROLE_ASSISTANT:
+                return msg.content ? '<' : '#';
+            case LLM.ROLE_USER:
+                return '>';
+            default:
+                return '*';
+        }
+    }
+
+    /**
+     *
+     * @param {LLMMessage[]} [messages]
+     * @returns {string}
+     */
+    toString (messages = this._chat) {
+        if (messages.length === 0) {
+            return '[<empty>]';
+        }
+        return messages.map((m) => {
+            switch (m.role) {
+                case LLM.ROLE_SYSTEM:
+                    return `--- system ---\n${m.content}\n--------------`;
+                default:
+                    return `${this._msgPrefix(m)} ${m.content}`;
+            }
+        })
+            .join('\n');
+    }
+
+    toJSON () {
+        return this.toArray();
+    }
+
+    /**
+     *
+     * @param {boolean} [needRaw=false]
+     * @returns {this}
+     */
+    debug (needRaw = false) {
+        // eslint-disable-next-line no-console
+        console.log('LLMSession#debug\n', this.toString(
+            needRaw ? this._chat : this.toArray()
+        ));
+        return this;
+    }
+
+    /**
+     *
+     * @param {LLMMessage} message
+     * @returns {this}
+     */
+    push (message) {
+        // if its system, append it on top
+        this._chat.push(message);
+        return this;
+    }
+
+    /**
+     *
+     * @param {string} content
+     * @returns {this}
+     */
+    systemPrompt (content) {
+        this.push({
+            role: LLM.ROLE_SYSTEM,
+            content
+        });
+        this._sort();
+        return this;
+    }
+
+    /**
+     *
+     * @param {LLMProviderOptions} [options={}]
+     * @returns {Promise<LLMMessage>}
+     */
+    async generate (options = {}) {
+        const result = await this._llm.generate(this, options);
+
+        this._generatedIndex = this._chat.length;
+        this._chat.push(result);
+
+        return result;
+    }
+
+    /**
+     *
+     * @param {QuickReply[]} quickReplies
+     * @returns {this}
+     */
+    send (quickReplies = undefined) {
+        if (!this._generatedIndex) {
+            // eslint-disable-next-line no-console
+            console.log('LLMSession', this.toString());
+            throw new Error('LLMSession: no message to send');
+        }
+
+        let messages = this._chat.splice(this._generatedIndex);
+        messages = messages.flatMap((msg) => LLM.toMessages(msg));
+        this._generatedIndex = null;
+        this._chat.push(...messages);
+
+        this._onSend(messages, quickReplies);
+
+        return this;
+    }
+
+}
+
+module.exports = LLMSession;

package/src/Processor.js

@@ -11,6 +11,8 @@ const Request = require('./Request');
 const Ai = require('./Ai');
 const ReturnSender = require('./ReturnSender');
 const { prepareState, mergeState, isUserInteraction } = require('./utils/stateVariables');
+const LLM = require('./LLM');
+const LLMMockProvider = require('./LLMMockProvider');
 
 /** @typedef {import('./wingbot/CustomEntityDetectionModel').Intent} Intent */
 /** @typedef {import('./ReducerWrapper')} ReducerWrapper */
@@ -19,6 +21,7 @@ const { prepareState, mergeState, isUserInteraction } = require('./utils/stateVa
 /** @typedef {import('./analytics/consts').TrackingCategory} TrackingCategory */
 /** @typedef {import('./analytics/consts').TrackingType} TrackingType */
 /** @typedef {import('./analytics/consts').ResponseFlag} ResponseFlag */
+/** @typedef {import('./LLM').LLMConfiguration} LLMConfiguration */
 
 /**
  * @typedef {object} AutoTypingConfig
@@ -110,6 +113,7 @@ const { prepareState, mergeState, isUserInteraction } = require('./utils/stateVa
  * @prop {string} [apiUrl] - Url for calling orchestrator API
  * @prop {Function} [fetch] - Fetch function for calling orchestrator API
  * @prop {number} [sessionDuration] - Session duration for analytic purposes
+ * @prop {LLMConfiguration} [llm] - LLM model configuration
  * @prop {Preloader<R>} [preloader]
  */
 
@@ -401,14 +405,19 @@ class Processor extends EventEmitter {
             return { status: 304 };
         }
 
+        const llm = new LLM({
+            provider: new LLMMockProvider(),
+            ...this.options.llm
+        });
+
         const result = await this
-            ._dispatch(message, pageId, messageSender, responderData, preloadPromise);
+            ._dispatch(message, pageId, messageSender, responderData, preloadPromise, llm);
 
         messageSender.defer(preloadPromise, this.options.log);
         return result;
     }
 
-    async _dispatch (message, pageId, messageSender, responderData, preloadPromise) {
+    async _dispatch (message, pageId, messageSender, responderData, preloadPromise, llm) {
         let req;
         let res;
         let state;
@@ -418,7 +427,14 @@ class Processor extends EventEmitter {
             ({
                 req, res, data, state
             } = await this
-                ._processMessage(message, pageId, messageSender, responderData, preloadPromise));
+                ._processMessage(
+                    message,
+                    pageId,
+                    messageSender,
+                    responderData,
+                    llm,
+                    preloadPromise
+                ));
 
             messageSender.defer(this._emitInteractionEvent(req, res, messageSender, state, data));
 
@@ -548,6 +564,7 @@ class Processor extends EventEmitter {
         pageId,
         messageSender,
         responderData,
+        llm,
         preloadPromise = null,
         senderMeta = null
     ) {
@@ -664,13 +681,13 @@ class Processor extends EventEmitter {
                     _sts: sessionTs,
                     _snew: sessionCreated
                 });
-            } else {
+            } /* else {
                 Object.assign(state, {
                     _snew: false
                 });
-            }
+            } */
 
-            prepareState(state, fromEvent, state._snew);
+            prepareState(state, fromEvent, state._snew && fromEvent);
 
             const features = [
                 ...(this.options.features || []),
@@ -690,7 +707,8 @@ class Processor extends EventEmitter {
                 options,
                 responderData,
                 configuration,
-                senderMeta
+                senderMeta,
+                llm
             );
             const postBack = this._createPostBack(postbackAcumulator, req, res, features);
 
@@ -852,6 +870,7 @@ class Processor extends EventEmitter {
                 pageId,
                 messageSender,
                 responderData,
+                llm,
                 res.senderMeta
             );
 
@@ -949,6 +968,7 @@ class Processor extends EventEmitter {
         pageId,
         messageSender,
         responderData,
+        llm,
         senderMeta
     ) {
         return postbackAcumulator.reduce((promise, postback) => promise
@@ -966,6 +986,7 @@ class Processor extends EventEmitter {
                     pageId,
                     messageSender,
                     responderData,
+                    llm,
                     null,
                     senderMeta
                 );

package/src/Responder.js

@@ -17,6 +17,8 @@ const {
     FEATURE_PHRASES
 } = require('./features');
 const transcriptFromHistory = require('./transcript/transcriptFromHistory');
+const LLM = require('./LLM');
+const LLMSession = require('./LLMSession');
 
 const TYPE_RESPONSE = 'RESPONSE';
 const TYPE_UPDATE = 'UPDATE';
@@ -28,8 +30,11 @@ const EXCEPTION_HOPCOUNT_THRESHOLD = 5;
 /** @typedef {import('./ReturnSender').SendOptions} SendOptions */
 /** @typedef {import('./ReturnSender').TextFilter} TextFilter */
 /** @typedef {import('./analytics/consts').TrackingCategory} TrackingCategory */
-/** @typedef {import('./analytics/consts').TrackingType} TrackingType */
 /** @typedef {import('./transcript/transcriptFromHistory').Transcript} Transcript */
+/** @typedef {import('./analytics/consts').TrackingType} TrackingType */
+
+/** @typedef {import('./LLM').LLMConfiguration} LLMConfiguration */
+/** @typedef {import('./LLMSession').LLMMessage} LLMMessage */
 
 /**
  * @enum {string} ExpectedInput
@@ -114,12 +119,14 @@ class Responder {
         options = {},
         data = {},
         configuration = {},
-        senderMeta = null
+        senderMeta = null,
+        llm = null
     ) {
         this._messageSender = messageSender;
         this._senderId = senderId;
         this._pageId = options.pageId;
         this.token = token;
+
         this._configuration = configuration;
 
         /**
@@ -214,20 +221,124 @@ class Responder {
 
         /** @type {SendOptions} */
         this._nextMessageSendOptions = null;
+
+        /** @type {LLM} */
+        this.llm = llm;
+
+        this.LLM_CTX_DEFAULT = 'default';
+
+        /** @type {Map<string,string[]>} */
+        this._llmContext = new Map([
+            [this.LLM_CTX_DEFAULT, []]
+        ]);
+    }
+
+    /**
+     *
+     * @param {string} systemPrompt
+     * @param {string} contextType
+     * @returns {this}
+     */
+    llmAddSystemPrompt (systemPrompt, contextType = this.LLM_CTX_DEFAULT) {
+        if (!systemPrompt || !systemPrompt.trim()) {
+            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());
+        return this;
+    }
+
+    llmSession (contextType = this.LLM_CTX_DEFAULT) {
+        const chat = this._getSystemContentForType(contextType)
+            .map((content) => ({ role: LLM.ROLE_SYSTEM, content }));
+
+        return new LLMSession(this.llm, chat, this._llmSend.bind(this));
+    }
+
+    /**
+     *
+     * @param {string} contextType
+     * @param {string[]} [callStack]
+     * @returns {string[]}
+     */
+    _getSystemContentForType (contextType, callStack = []) {
+        if (new Set(callStack).size < callStack.length) {
+            throw new Error(`Circular reference detected: contextType -> ${callStack}`);
+        }
+
+        if (!this._llmContext.has(contextType)) {
+            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());
+    }
+
+    async llmSessionWithHistory (contextType = this.LLM_CTX_DEFAULT) {
+        const {
+            transcriptAnonymize,
+            transcriptFlag,
+            transcriptLength
+        } = this.llm.configuration;
+
+        const systems = this._getSystemContentForType(contextType);
+        const transcript = await this.getTranscript(transcriptLength, transcriptFlag);
+
+        const chat = [
+            ...systems.map((content) => ({ role: LLM.ROLE_SYSTEM, content })),
+            ...LLM.anonymizeTranscript(transcript, transcriptAnonymize)
+        ];
+
+        return new LLMSession(this.llm, chat, this._llmSend.bind(this));
+    }
+
+    /**
+     *
+     * @param {LLMMessage[]} messages
+     * @param {QuickReply[]} quickReplies
+     */
+    _llmSend (messages, quickReplies) {
+        this.setFlag(LLM.GPT_FLAG);
+
+        const { persona } = this.llm.configuration;
+
+        if (typeof persona === 'string') {
+            this.setPersona({ name: persona });
+        } else if (persona) {
+            this.setPersona(persona);
+        }
+
+        messages.forEach((m, i) => {
+            const addQuickReply = i === (messages.length - 1);
+            this.text(m.content, addQuickReply ? quickReplies : null);
+        });
+
+        if (persona) {
+            this.setPersona({ name: null });
+        }
     }
 
     _findPersonaConfiguration (name) {
+        // @ts-ignore
         if (!name || !this._configuration.persona) {
             return null;
         }
+        // @ts-ignore
         if (!this._configuration._cachedPersonas) {
-            // eslint-disable-next-line no-param-reassign
+            // @ts-ignore
             this._configuration._cachedPersonas = new Map(
+                // @ts-ignore
                 Object.entries(this._configuration.persona)
                     .map(([k, v]) => [k === PERSONA_DEFAULT ? k : tokenize(k), v])
             );
         }
         const nameKey = name === PERSONA_DEFAULT ? PERSONA_DEFAULT : tokenize(name);
+        // @ts-ignore
         return this._configuration._cachedPersonas.get(nameKey);
     }
 
@@ -252,16 +363,16 @@ class Responder {
      */
     async getTranscript (limit = 10, onlyFlag = null, skipThisTurnaround = false) {
         const { chatLogStorage, timestamp } = this._messageSender;
-        if (!chatLogStorage) {
-            return [];
+        let transcript = [];
+        if (chatLogStorage) {
+            transcript = await transcriptFromHistory(
+                chatLogStorage,
+                this._senderId,
+                this._pageId,
+                limit,
+                onlyFlag
+            );
         }
-        const transcript = await transcriptFromHistory(
-            chatLogStorage,
-            this._senderId,
-            this._pageId,
-            limit,
-            onlyFlag
-        );
         if (!skipThisTurnaround) {
             const { responseTexts = [], requestTexts = [] } = this._messageSender;
             transcript.push(...requestTexts.map((text) => ({

package/src/ReturnSender.js

@@ -11,6 +11,7 @@ const extractText = require('./transcript/extractText');
 /** @typedef {import('./Request')} Request */
 /** @typedef {import('./Responder')} Responder */
 /** @typedef {import('./Processor').TrackingObject} TrackingObject */
+/** @typedef {import('./LLMContext').LLMMessage} LLMMessage */
 
 /**
  * @callback GetInteractions

package/src/Tester.js

@@ -18,6 +18,7 @@ const ResponseAssert = require('./testTools/ResponseAssert');
 const Router = require('./Router'); // eslint-disable-line no-unused-vars
 const ReducerWrapper = require('./ReducerWrapper'); // eslint-disable-line no-unused-vars
 const { FEATURE_TEXT } = require('./features');
+const LLMMockProvider = require('./LLMMockProvider');
 
 /** @typedef {import('./Processor').ProcessorOptions<Router>} ProcessorOptions */
 
@@ -100,6 +101,10 @@ class Tester {
             log,
             // @ts-ignore
             loadUsers: false,
+            llm: {
+                provider: new LLMMockProvider(),
+                ...processorOptions.llm
+            },
             ...processorOptions
         }));
 

package/src/resolvers/button.js

@@ -28,8 +28,8 @@ function button (params, context) {
         buttons = [],
         text = null
     } = params;
-    const compiledText = cachedTranslatedCompilator(text);
 
+    const compiledText = cachedTranslatedCompilator(text);
     const condition = getCondition(params, context, 'button');
 
     const ret = isLastIndex ? Router.END : Router.CONTINUE;

package/src/resolvers/include.js

@@ -4,8 +4,9 @@
 'use strict';
 
 function include (params, context, plugins) {
-    const includedRouter = context.blocks
-        .find((block) => block.staticBlockId === params.staticBlockId);
+    const includedRouter = context.nestedBlocksByStaticId
+        ? context.nestedBlocksByStaticId.get(params.staticBlockId)
+        : context.blocks.find((block) => block.staticBlockId === params.staticBlockId);
 
     if (!includedRouter) {
         throw new Error(`Block ${params.staticBlockId} not found!`);

package/src/resolvers/message.js

@@ -289,15 +289,13 @@ function message (params, context = {}) {
     }
 
     // parse quick replies
-    let quickReplies = null;
+    let quickReplies;
     if (params.replies && !Array.isArray(params.replies)) {
         throw new Error('Replies should be an array');
-    } else if (params.replies && params.replies.length > 0) {
-        quickReplies = parseReplies(params.replies, linksMap, context);
     }
 
     // compile condition
-    const condition = getCondition(params, context, 'Message condition');
+    let condition;
 
     const ret = isLastIndex ? Router.END : Router.CONTINUE;
 
@@ -306,6 +304,17 @@ function message (params, context = {}) {
      * @param {Responder} res
      */
     return (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);
+            } else {
+                quickReplies = null;
+            }
+        }
+
         const data = stateData(req, res, configuration);
 
         // filter supported messages

package/src/resolvers/postback.js

@@ -32,11 +32,15 @@ function postback (params, context) {
         }
     }
 
-    const condition = getCondition(params, context, 'postback');
+    let condition;
 
     const ret = isLastIndex ? Router.END : Router.CONTINUE;
 
     return (req, res, postBack) => {
+        if (condition === undefined) {
+            condition = getCondition(params, context, 'postback');
+        }
+
         if (!action || !shouldExecuteResolver(req, params)) {
             return ret;
         }

package/src/utils/stateData.js

@@ -20,16 +20,21 @@ const { dateToISO8601String, zeroHourDate } = require('./datetime');
 
 /**
  *
- * @param {IStateRequest} req
- * @param {Responder} res
- * @param {object} configuration
+ * @param {IStateRequest} [req]
+ * @param {Responder} [res]
+ * @param {object} [configuration]
  * @param {object} [stateOverride]
  * @returns {object}
  */
-module.exports = function stateData (req, res = null, configuration = null, stateOverride = {}) {
-    const c = configuration || req.configuration;
+module.exports = function stateData (
+    req = null,
+    res = null,
+    configuration = null,
+    stateOverride = {}
+) {
+    const c = configuration || (req && req.configuration) || (res && res._configuration);
 
-    const $this = req.text();
+    const $this = req ? req.text() : '';
 
     const now = new Date();
 
@@ -42,15 +47,20 @@ module.exports = function stateData (req, res = null, configuration = null, stat
 
     const {
         senderId,
-        pageId
-    } = req;
+        pageId,
+        state
+    } = req || {
+        senderId: res._senderId,
+        pageId: res._pageId,
+        state: res.options.state
+    };
 
     return {
         senderId,
         pageId,
         c,
         configuration: c,
-        ...req.state,
+        ...state,
         ...(res ? res.newState : {}),
         ...stateOverride,
         $this,
@@ -59,7 +69,7 @@ module.exports = function stateData (req, res = null, configuration = null, stat
         $tomorrow,
         $yesterday,
         // yes - res because of circular dependency
-        ...(res && req.actionData()),
+        ...(res && req && req.actionData()),
         ...(res ? res.data : {}),
         $input: $this
     };