wingbot 3.69.7 → 3.70.0-alpha.4

package/src/LLMSession.js

@@ -0,0 +1,228 @@
+/**
+ * @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<any>[]} [chat]
+     * @param {SendCallback} [onSend]
+     */
+    constructor (llm, chat = [], onSend = () => {}) {
+        this._llm = llm;
+
+        this._onSend = onSend;
+
+        /** @type {LLMMessage<any>[]} */
+        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 () {
+        /** @type {LLMMessage<any>[]} */
+        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<any>>}
+     */
+    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
@@ -98,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';
 
 /**
@@ -114,12 +129,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 +231,156 @@ class Responder {
 
         /** @type {SendOptions} */
         this._nextMessageSendOptions = null;
+
+        /** @type {LLM} */
+        this.llm = llm;
+
+        this.LLM_CTX_DEFAULT = 'default';
+
+        /** @type {Map<string,(PromptSource|Promise<string>)[]>} */
+        this._llmContext = new Map([
+            [this.LLM_CTX_DEFAULT, []]
+        ]);
+    }
+
+    /**
+     *
+     * @param {PromptSource} systemPrompt
+     * @param {string} contextType
+     * @returns {this}
+     */
+    llmAddSystemPrompt (systemPrompt, contextType = this.LLM_CTX_DEFAULT) {
+        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);
+
+        return this;
+    }
+
+    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 {Promise<string[]>}
+     */
+    async _getSystemContentForType (contextType, callStack = []) {
+        if (new Set(callStack).size < callStack.length) {
+            throw new Error(`Circular reference detected: contextType -> ${callStack}`);
+        }
+
+        if (!this._llmContext.has(contextType)) {
+            return [];
+        }
+
+        /** @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) {
+        const {
+            transcriptAnonymize,
+            transcriptFlag,
+            transcriptLength
+        } = this.llm.configuration;
+
+        const [systems, transcript] = await Promise.all([
+            this._getSystemContentForType(contextType),
+            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 +405,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) => ({
@@ -547,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
@@ -574,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)
@@ -624,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/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/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;