wingbot 3.71.6 → 3.72.0

package/src/LLM.js

@@ -3,16 +3,72 @@
  */
 'use strict';
 
+const { getSetState } = require('./utils/getUpdate');
 const { PHONE_REGEX, EMAIL_REGEX } = require('./systemEntities/regexps');
+const getCondition = require('./utils/getCondition');
+const stateData = require('./utils/stateData');
+const Ai = require('./Ai');
+// const getCondition = require('./utils/getCondition');
 
 /** @typedef {import('./Responder')} Responder */
+/** @typedef {import('./AiMatching').PreprocessorOutput} PreprocessorOutput */
+/** @typedef {import('./Request')} Request */
 /** @typedef {import('./Responder').Persona} Persona */
 /** @typedef {import('./Router').BaseConfiguration} BaseConfiguration */
 /** @typedef {import('./LLMSession').LLMMessage<any>} LLMMessage */
 /** @typedef {import('./LLMSession').ToolCall} ToolCall */
 /** @typedef {import('./LLMSession').LLMRole} LLMRole */
+/** @typedef {import('./LLMSession').FilterScope} FilterScope */
 /** @typedef {import('./LLMSession')} LLMSession */
 /** @typedef {import('./transcript/transcriptFromHistory').Transcript} Transcript */
+/** @typedef {import('./utils/getCondition').ConditionDefinition} ConditionDefinition */
+/** @typedef {import('./utils/getCondition').ConditionContext} ConditionContext */
+/** @typedef {import('./utils/stateData').IStateRequest} IStateRequest */
+
+/** @typedef {string|'_DISCARD'} EvaluationRuleAction */
+
+/**
+ * @typedef {object} EvaluationRuleData
+ * @prop {EvaluationRuleAction} [action]
+ * @prop {object} [setState]
+ */
+
+/**
+ * @typedef {object} RuleDefinitionData
+ * @prop {string[]} aiTags
+ * @prop {EvaluationRuleAction} [targetRouteId]
+ */
+
+/**
+ * @typedef {EvaluationRuleData & RuleDefinitionData & ConditionDefinition} EvaluationRule
+ */
+
+/**
+ * @typedef {object} PrepocessedRuleData
+ * @prop {Function} condition
+ * @prop {PreprocessorOutput} rule
+ */
+
+/**
+ * @typedef {EvaluationRuleData & PrepocessedRuleData} PreprocessedRule
+ */
+
+/**
+ * @typedef {object} RuleScore
+ * @prop {number} score
+ */
+
+/**
+ * @typedef {RuleScore & PreprocessedRule} RuleWithScore
+ */
+
+/**
+ * @typedef {object} EvaluationResult
+ * @prop {string} action
+ * @prop {boolean} discard
+ * @prop {RuleWithScore[]} results
+ * @prop {object} setState
+ */
 
 /**
  * @callback LLMChatProviderPrompt
@@ -82,6 +138,13 @@ class LLM {
 
     static GPT_FLAG = 'gpt';
 
+    /** @type {FilterScope} */
+    static FILTER_SCOPE_CONVERSATION = 'conversation';
+
+    static EVALUATION_ACTIONS = {
+        DISCARD: '_DISCARD'
+    };
+
     /** @type {AnonymizeRegexp[]} */
     static anonymizeRegexps = [
         { replacement: '@PHONE', regex: new RegExp(PHONE_REGEX.source, 'g') },
@@ -91,8 +154,9 @@ class LLM {
     /**
      *
      * @param {LLMConfiguration} configuration
+     * @param {Ai} ai
      */
-    constructor (configuration) {
+    constructor (configuration, ai) {
         const { provider, ...rest } = configuration;
 
         this._configuration = {
@@ -107,6 +171,25 @@ class LLM {
 
         /** @type {LLMChatProvider} */
         this._provider = provider;
+
+        this._ai = ai;
+
+        /** @type {LLMMessage} */
+        this._lastResult = null;
+    }
+
+    /**
+     * @returns {Ai}
+     */
+    get ai () {
+        return this._ai;
+    }
+
+    /**
+     * @returns {LLMMessage}
+     */
+    get lastResult () {
+        return this._lastResult;
     }
 
     /**
@@ -148,7 +231,7 @@ class LLM {
             ...options
         };
 
-        const prompt = session.toArray();
+        const prompt = session.toArray(true);
         const result = await this._provider.requestChat(prompt, opts);
         this._logPrompt(prompt, result);
         return result;
@@ -160,6 +243,7 @@ class LLM {
      * @param {LLMMessage} result
      */
     _logPrompt (prompt, result) {
+        this._lastResult = result;
         this._configuration.logger.logPrompt({
             prompt, result
         });
@@ -188,6 +272,103 @@ class LLM {
         }));
     }
 
+    /**
+     *
+     * @param {EvaluationRule[]} rules
+     * @param {ConditionContext} [context]
+     * @returns {PreprocessedRule[]}
+     */
+    static preprocessEvaluationRules (rules, context = {}) {
+        const {
+            linksMap = new Map(),
+            ai = Ai.ai
+        } = context;
+
+        return rules.map((evalRule) => {
+            const { aiTags, targetRouteId, ...rest } = evalRule;
+
+            const condition = getCondition(rest, context);
+            const rule = ai.matcher.preprocessRule(aiTags);
+
+            let { action = null } = evalRule;
+
+            if (!action && targetRouteId && linksMap.has(targetRouteId)) {
+                action = linksMap.get(targetRouteId);
+            }
+
+            return {
+                ...rest,
+                condition,
+                rule
+            };
+        });
+    }
+
+    /**
+     * Returns all actions, which has been recognized
+     * with higher score than threshold, but
+     *
+     * - _DISCARD action discards any other rules (will return all relevant _DISCARD actions)
+     * - only the TOP ranked "interaction" action will be returned
+     * - actions will come in THE SAME order, so the "setState" will be applied in the same order
+     *
+     *
+     * @param {LLMMessage|string} result
+     * @param {PreprocessedRule[]} rules
+     * @param {IStateRequest} req
+     * @param {Responder} res
+     * @returns {Promise<EvaluationResult>}
+     */
+    async evaluateResultWithRules (result, rules, req, res) {
+        const text = typeof result === 'string' ? result : result.content;
+        const nlpResult = await this._ai.queryModel(text, req);
+        const state = stateData(req, res);
+
+        let topRankedAction = null;
+        let topActionScore = 0;
+        let discard = false;
+        const setState = {};
+
+        const sAct = Object.values(LLM.EVALUATION_ACTIONS);
+
+        const results = rules
+            .filter((rule) => rule.condition(req, res))
+            .map((rule) => {
+                const matched = this._ai.matcher
+                    .matchText(text, rule.rule, nlpResult, state);
+
+                if (!matched || matched.score < this._ai.threshold) {
+                    return null;
+                }
+
+                if (rule.action === LLM.EVALUATION_ACTIONS.DISCARD) {
+                    discard = true;
+                } else if (rule.action && topActionScore < matched.score) {
+                    topRankedAction = rule.action;
+                    topActionScore = matched.score;
+                }
+
+                return {
+                    ...rule,
+                    score: matched.score
+                };
+            })
+            .filter((rule) => rule !== null
+                && (!discard || rule.action === LLM.EVALUATION_ACTIONS.DISCARD)
+                && (!rule.action || rule.action === topRankedAction || sAct.includes(rule.action)));
+
+        results.forEach((rule) => {
+            Object.assign(setState, getSetState(rule.setState, req, res, setState));
+        });
+
+        return {
+            setState,
+            results,
+            discard,
+            action: discard ? null : topRankedAction
+        };
+    }
+
 }
 
 module.exports = LLM;

package/src/LLMSession.js

@@ -13,6 +13,8 @@ const LLM = require('./LLM');
 /** @typedef {'tool'} LLMToolRole */
 /** @typedef {LLMChatRole|LLMSystemRole|LLMToolRole|string} LLMRole */
 
+/** @typedef {LLMRole|'conversation'} FilterScope */
+
 /** @typedef {'stop'|'length'|'tool_calls'|'content_filter'} LLMFinishReason */
 
 /**
@@ -38,6 +40,19 @@ const LLM = require('./LLM');
  * @param {QuickReply[]} quickReplies
  */
 
+/**
+ * @callback LLMFilterFn
+ * @param {string} text
+ * @param {LLMRole} role
+ * @returns {boolean|string}
+ */
+
+/**
+ * @typedef {object} LLMFilter
+ * @prop {LLMFilterFn} filter
+ * @prop {FilterScope} scope
+ */
+
 /**
  * @class LLMSession
  */
@@ -48,8 +63,9 @@ class LLMSession {
      * @param {LLM} llm
      * @param {LLMMessage<any>[]} [chat]
      * @param {SendCallback} [onSend]
+     * @param {LLMFilter[]} [filters=[]]
      */
-    constructor (llm, chat = [], onSend = () => {}) {
+    constructor (llm, chat = [], onSend = () => {}, filters = []) {
         this._llm = llm;
 
         this._onSend = onSend;
@@ -60,6 +76,13 @@ class LLMSession {
         this._generatedIndex = null;
 
         this._sort();
+
+        /** @type {LLMFilter[]} */
+        this._filters = filters;
+
+        this._SCOPE_CONVERSATION_ROLES = [
+            LLM.ROLE_ASSISTANT, LLM.ROLE_USER
+        ];
     }
 
     _sort (what = this._chat) {
@@ -114,10 +137,43 @@ class LLMSession {
     }
 
     /**
+     *
+     * @param {boolean} [filtered=false]
      * @returns {LLMMessage[]}
      */
-    toArray () {
-        return this._mergeSystem();
+    toArray (filtered = false) {
+        const messages = this._mergeSystem();
+        if (!filtered || this._filters.length === 0) {
+            return messages;
+        }
+        return messages
+            .map((message) => {
+                if (!message.content) {
+                    return message;
+                }
+                const content = this._filters.reduce((text, filter) => {
+                    if (!text) {
+                        return text;
+                    }
+                    if (filter.scope !== message.role
+                        && (filter.scope !== LLM.FILTER_SCOPE_CONVERSATION
+                            || !this._SCOPE_CONVERSATION_ROLES.includes(message.role))) {
+                        return text;
+                    }
+                    const res = filter.filter(text, message.role);
+                    return res === true ? text : res;
+                }, message.content);
+
+                if (!content) {
+                    return null;
+                }
+
+                return {
+                    ...message,
+                    content
+                };
+            })
+            .filter((message) => message !== null);
     }
 
     /**
@@ -200,6 +256,20 @@ class LLMSession {
         return this;
     }
 
+    /**
+     *
+     * @param {LLMFilter|LLMFilter[]} filter
+     * @returns {this}
+     */
+    addFilter (filter) {
+        if (Array.isArray(filter)) {
+            this._filters.push(...filter);
+        } else {
+            this._filters.push(filter);
+        }
+        return this;
+    }
+
     /**
      *
      * @param {LLMProviderOptions} [options={}]
@@ -214,6 +284,23 @@ class LLMSession {
         return result;
     }
 
+    /**
+     *
+     * @returns {string}
+     */
+    lastResponse () {
+        const messages = [];
+        for (let i = this._chat.length - 1; i >= 0; i--) {
+            const message = this._chat[i];
+
+            if (message.role !== LLM.ROLE_ASSISTANT || !message.content) {
+                break;
+            }
+            messages.unshift(message.content);
+        }
+        return messages.join('\n\n');
+    }
+
     /**
      *
      * @param {boolean} [dontMarkAsSent=false]

package/src/Processor.js

@@ -416,7 +416,7 @@ class Processor extends EventEmitter {
             });
         }
 
-        const llm = new LLM(llmOptions);
+        const llm = new LLM(llmOptions, Ai.ai);
 
         const result = await this
             ._dispatch(message, pageId, messageSender, responderData, preloadPromise, llm);

package/src/Responder.js

@@ -34,7 +34,14 @@ const EXCEPTION_HOPCOUNT_THRESHOLD = 5;
 /** @typedef {import('./analytics/consts').TrackingType} TrackingType */
 
 /** @typedef {import('./LLM').LLMConfiguration} LLMConfiguration */
+/** @typedef {import('./LLM').PreprocessedRule} PreprocessedRule */
+/** @typedef {import('./LLM').EvaluationRuleAction} EvaluationRuleAction */
+/** @typedef {import('./LLM').EvaluationResult} EvaluationResult */
 /** @typedef {import('./LLMSession').LLMMessage} LLMMessage */
+/** @typedef {import('./LLMSession').LLMFilterFn} LLMFilterFn */
+/** @typedef {import('./LLMSession').LLMFilter} LLMFilter */
+/** @typedef {import('./LLMSession').FilterScope} FilterScope */
+/** @typedef {import('./utils/stateData').IStateRequest} IStateRequest */
 
 /**
  * @enum {string} ExpectedInput
@@ -243,6 +250,28 @@ class Responder {
         this._llmContext = new Map([
             [this.LLM_CTX_DEFAULT, []]
         ]);
+
+        /** @type {Map<string,PreprocessedRule[]>} */
+        this._llmResultRules = new Map([
+            [this.LLM_CTX_DEFAULT, []]
+        ]);
+
+        /** @type {Map<string,LLMFilter[]>} */
+        this._llmFilters = new Map([
+            [this.LLM_CTX_DEFAULT, []],
+            [null, []]
+        ]);
+    }
+
+    /**
+     *
+     * @deprecated use llmAddInstructions() instead
+     * @param {PromptSource} systemPrompt
+     * @param {string} [contextType]
+     * @returns {this}
+     */
+    llmAddSystemPrompt (systemPrompt, contextType) {
+        return this.llmAddInstructions(systemPrompt, contextType);
     }
 
     /**
@@ -251,7 +280,7 @@ class Responder {
      * @param {string} contextType
      * @returns {this}
      */
-    llmAddSystemPrompt (systemPrompt, contextType = this.LLM_CTX_DEFAULT) {
+    llmAddInstructions (systemPrompt, contextType = this.LLM_CTX_DEFAULT) {
         if (!systemPrompt) {
             return this;
         }
@@ -264,12 +293,109 @@ class Responder {
         return this;
     }
 
+    /**
+     *
+     * @param {LLMFilter|LLMFilterFn} filter
+     * @param {FilterScope} [scope]
+     * @param {string} [contextType]
+     * @returns {this}
+     */
+    llmAddFilter (
+        filter,
+        scope = LLM.FILTER_SCOPE_CONVERSATION,
+        contextType = null
+    ) {
+        /** @type {LLMFilter} */
+        const addFilter = typeof filter === 'function'
+            ? {
+                filter,
+                scope
+            }
+            : filter;
+
+        if (!this._llmFilters.has(contextType)) {
+            this._llmFilters.set(contextType, []);
+        }
+        this._llmFilters.get(contextType).push(addFilter);
+        return this;
+    }
+
+    /**
+     *
+     * @param {string[]|PreprocessedRule} rule
+     * @param {EvaluationRuleAction} [action]
+     * @param {object} [setState]
+     * @param {string} [contextType]
+     * @returns {this}
+     */
+    llmAddResultRule (
+        rule,
+        action = null,
+        setState = null,
+        contextType = this.LLM_CTX_DEFAULT
+    ) {
+        let addRule = rule;
+
+        if (Array.isArray(addRule)) {
+            [addRule] = LLM.preprocessEvaluationRules([{
+                // @ts-ignore
+                aiTags: rule,
+                action,
+                setState
+            }], {
+                ai: this.llm.ai
+            });
+        }
+
+        if (!this._llmResultRules.has(contextType)) {
+            this._llmResultRules.set(contextType, []);
+        }
+        this._llmResultRules.get(contextType).push(addRule);
+        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));
+        const filters = this._filtersForContext(contextType);
+        return new LLMSession(this.llm, chat, this._llmSend.bind(this), filters);
+    }
+
+    /**
+     *
+     * @param {LLMSession} session
+     * @param {string} [contextType]
+     * @returns {Promise<EvaluationResult>}
+     */
+    async llmEvaluate (session, contextType = this.LLM_CTX_DEFAULT) {
+        const rules = this._llmResultRules.get(contextType) || [];
+        const text = session.lastResponse();
+
+        if (rules.length === 0 || !text) {
+            return {
+                action: null,
+                setState: {},
+                results: [],
+                discard: false
+            };
+        }
+
+        /** @type {IStateRequest} */
+        const req = {
+            state: this.options.state,
+            text: () => text,
+            senderId: this._senderId,
+            pageId: this._pageId,
+            actionData: () => this._data,
+            isConfidentInput: () => false
+        };
+
+        const result = await this.llm.evaluateResultWithRules(text, rules, req, this);
+        this.setState(result.setState);
+
+        return result;
     }
 
     async _replaceAsync (str, regex, asyncFn) {
@@ -339,7 +465,20 @@ class Responder {
             ...LLM.anonymizeTranscript(transcript, transcriptAnonymize)
         ];
 
-        return new LLMSession(this.llm, chat, this._llmSend.bind(this));
+        const filters = this._filtersForContext(contextType);
+        return new LLMSession(this.llm, chat, this._llmSend.bind(this), filters);
+    }
+
+    /**
+     *
+     * @param {string|null} contextType
+     * @returns {LLMFilter[]}
+     */
+    _filtersForContext (contextType) {
+        return [
+            ...(this._llmFilters.get(contextType) || []),
+            ...this._llmFilters.get(null)
+        ];
     }
 
     /**
@@ -394,6 +533,7 @@ class Responder {
      */
     setFlag (flag) {
         this._senderMeta.flag = flag;
+        // @ts-ignore
         return this;
     }
 

package/src/ReturnSender.js

@@ -162,7 +162,7 @@ class ReturnSender {
         };
 
         /** @type {PromptInfo[]} */
-        this._prompts = [];
+        this.prompts = [];
 
         this._responseTexts = [];
 
@@ -199,7 +199,7 @@ class ReturnSender {
      * @param {PromptInfo} promptInfo
      */
     logPrompt (promptInfo) {
-        this._prompts.push(promptInfo);
+        this.prompts.push(promptInfo);
     }
 
     /**
@@ -669,7 +669,7 @@ class ReturnSender {
         const payload = {};
         const meta = {
             actions: this._visitedInteractions.slice(),
-            prompts: this._prompts
+            prompts: this.prompts
         };
 
         if (req) {
@@ -697,7 +697,7 @@ class ReturnSender {
     _createMeta (req = null, res = null) { // eslint-disable-line no-unused-vars
         const meta = {
             visitedInteractions: this._visitedInteractions.slice(),
-            prompts: this._prompts
+            prompts: this.prompts
         };
 
         if (req) {