wingbot 3.69.7 → 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,8 +1,8 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": ["es6"],
-        "target": "es2019",
+        "lib": ["es2019", "es2020.promise", "es2020.bigint", "es2020.string", "dom"],
+        "target": "ESNext",
         "allowSyntheticDefaultImports": true,
         "checkJs": true,
         "resolveJsonModule": true
@@ -14,4 +14,4 @@
         "doc",
         "docs"
     ]
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.69.7",
+  "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",
@@ -61,7 +62,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"
   },
@@ -69,4 +70,4 @@
     "axios": "^1.6.4",
     "handlebars": "^4.0.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,12 @@ 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);
+        // @ts-ignore
+        this._linksMap = linksMap;
 
-        this._buildRoutes(block.routes);
+        // @ts-ignore
+        this._buildRoutes(block.routes, nestedBlocksByStaticId);
 
         this._configTs = setConfigTimestamp;
 
@@ -577,74 +583,79 @@ 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 });
-        });
-    }
-
     /**
+     *
+     * returns {[LinksMap, BlockMap]}
      *
      * @param {Block} block
-     * @returns {LinksMap}
      */
     _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 +693,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 +804,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 +815,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 +876,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 +906,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<any>} 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,67 @@
+/**
+ * @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',
+        // 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: `${options.model || LLMMockProvider.DEFAULT_MODEL}:${prompt.map((m) => m.content).join(' ')}`
+        };
+    }
+
+}
+
+module.exports = LLMMockProvider;