wingbot 3.71.6 → 3.72.1

package/src/resolvers/contextMessage.js

@@ -8,30 +8,47 @@ const Router = require('../Router');
 const Responder = require('../Responder');
 const { getLanguageText } = require('./utils');
 const compileWithState = require('../utils/compileWithState');
+const LLM = require('../LLM');
 
 /** @typedef {import('../BuildRouter').BotContext<any>} BotContext */
 /** @typedef {import('../Router').Resolver<any>} Resolver */
 /** @typedef {import('./utils').Translations} Translations */
+/** @typedef {import('../LLM').EvaluationRule} EvaluationRule */
+
+/**
+ * @typedef {object} ContextMessageParams
+ * @property {Translations} context
+ * @property {string} [type]
+ * @property {EvaluationRule[]} [rules]
+ */
 
 /**
  *
- * @param {object} params
- * @param {Translations} params.context
- * @param {string} [params.type]
+ * @param {ContextMessageParams} params
  * @param {BotContext} context
  * @returns {Resolver}
  */
 // eslint-disable-next-line no-unused-vars
 function contextMessage (params, context) {
 
+    const { rules = [] } = params;
+    const preprocessedRules = LLM.preprocessEvaluationRules(rules, context);
+
     return async (req, res) => {
-        res.llmAddSystemPrompt((r) => {
+        res.llmAddInstructions((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);
 
+        preprocessedRules.forEach((rule) => res.llmAddResultRule(
+            rule,
+            undefined,
+            undefined,
+            params.type
+        ));
+
         return Router.CONTINUE;
     };
 }

package/src/resolvers/message.js

@@ -23,8 +23,11 @@ const { vars, VAR_TYPES } = require('../utils/stateVariables');
 const LLM = require('../LLM');
 
 /** @typedef {import('../Responder').VoiceControl} VoiceControl */
+/** @typedef {import('../BuildRouter').LinksMap} LinksMap */
 /** @typedef {import('./utils').Translations} Translations */
 /** @typedef {import('./utils').TextObject} TextObject */
+/** @typedef {import('../utils/getCondition').ConditionDefinition} ConditionDefinition */
+/** @typedef {import('../utils/getCondition').ConditionContext} ConditionContext */
 /**
  * Returns voice control props from params
  *
@@ -68,6 +71,30 @@ function getVoiceControlFromParams (params, lang = null) {
     return Object.keys(voiceControl).length > 0 ? voiceControl : null;
 }
 
+/**
+ * @typedef {object} QuickReplyData
+ * @prop {boolean} [isLocation]
+ * @prop {boolean} [isEmail]
+ * @prop {boolean} [isPhone]
+ * @prop {boolean} [trackAsNegative]
+ * @prop {string} [action]
+ * @prop {string} [targetRouteId]
+ * @prop {{l:string,t:string[]}[] | string} [title]
+ * @prop {object} [setState]
+ * @prop {string[]} [aiTags]
+ * @prop {{l:string,t:string[]}[] | string} [aiTitle]
+ */
+
+/**
+ * @typedef {ConditionDefinition & QuickReplyData} QuickReply
+ */
+
+/**
+ *
+ * @param {QuickReply[]} replies
+ * @param {LinksMap} linksMap
+ * @param {ConditionContext} context
+ */
 function parseReplies (replies, linksMap, context) {
     return replies.map((reply) => {
 
@@ -314,8 +341,9 @@ function message (params, context = {}) {
     /**
      * @param {Request} req
      * @param {Responder} res
+     * @param {Function } postBack
      */
-    return async (req, res) => {
+    return async (req, res, postBack) => {
         if (condition === undefined) {
             condition = getCondition(params, context, 'Message condition');
         }
@@ -425,6 +453,20 @@ function message (params, context = {}) {
             await session.systemPrompt(text)
                 .generate();
 
+            const evaluation = await res.llmEvaluate(session, params.llmContextType);
+
+            if (evaluation.discard) {
+                if (isLastMessage && !req.actionData()._resolverTag) {
+                    res.finalMessageSent = true;
+                }
+                return ret;
+            }
+
+            if (evaluation.action) {
+                postBack(evaluation.action);
+                return Router.END;
+            }
+
             // if (!response.content) {
             //    // no response?
             // }

package/src/resolvers/utils.js

@@ -31,17 +31,26 @@ const WEBVIEW_COMPACT = 'compact';
  * @prop {string|null} p - purpose
  */
 
+/**
+ * null = text+voice
+ * t = text only
+ * v = voice only
+ * s = ssml
+ *
+ * @typedef {"t"|"v"|"s"|null} Purpose
+ */
+
 /**
  * @typedef Translation
  * @property {string|string[]} t - text alternatives
  * @property {string | null} l - language
- * @property {string|string[]} [p] - purposes
- * null = default + voice
- * t = text
- * v = voice
- * s = ssml
+ * @property {Purpose | Purpose[]} [p] - purposes
  */
 
+/**
+ * @param {string | string[] | Translation | Translation[]} translations
+ * @returns {translations is Translation[]}
+ */
 function isArrayOfObjects (translations) {
     return Array.isArray(translations)
         && typeof translations[0] === 'object'

package/src/testTools/PromptAssert.js

@@ -0,0 +1,184 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+const assert = require('assert');
+const asserts = require('./asserts');
+
+const { ex } = asserts;
+
+/** @typedef {import('../LLM').PromptInfo} PromptInfo */
+/** @typedef {import('../LLM').LLMMessage} LLMMessage */
+/** @typedef {import('../LLM').LLMRole} LLMRole */
+
+/**
+ * @class PromptAssert
+ */
+class PromptAssert {
+
+    /**
+     *
+     * @param {PromptInfo[]} prompts
+     */
+    constructor (prompts) {
+        this._prompts = prompts;
+    }
+
+    /**
+     * Check if recent instruction contains selected string
+     *
+     * @param {string} search
+     * @returns {this}
+     */
+    instructionContains (search) {
+        const messages = this._flatPrompt((m) => m.role === 'system');
+        this._promptContains(search, messages, false, 'of role "system"');
+        return this;
+    }
+
+    /**
+     * Check if recent prompt input contains selected string
+     *
+     * @param {string} search
+     * @returns {this}
+     */
+    promptContains (search) {
+        this._promptContains(search, this._flatPrompt());
+        return this;
+    }
+
+    /**
+     * Check if recent results contains selected string
+     *
+     * @param {string} search
+     * @returns {this}
+     */
+    resultContains (search) {
+        this._promptContains(search, this._flatResults());
+        return this;
+    }
+
+    /**
+     *
+     * @param {(value: LLMMessage, index: number, array: LLMMessage[]) => unknown} filter
+     * @returns {LLMMessage[]}
+     */
+    _flatPrompt (filter = () => true) {
+        return this._prompts
+            .flatMap((prompt) => prompt.prompt
+                .filter(filter));
+    }
+
+    /**
+     *
+     * @returns {LLMMessage[]}
+     */
+    _flatResults () {
+        return this._prompts
+            .map((prompt) => prompt.result);
+    }
+
+    _promptContains (search, messages, notContains = false, addMessage = 'No LLM message found') {
+        if (messages.length === 0) {
+            PromptAssert.debug(this._prompts, true);
+            assert.fail(ex(`No LLM message ${addMessage}`, search));
+        }
+
+        const found = messages.some((m) => asserts.llmContains(m, search, false));
+        // console.log({ found, messages, notContains });
+        if (notContains === found) {
+            PromptAssert.debug(this._prompts, true);
+            assert.fail(ex(
+                `Text${notContains ? '' : ' not'} found in LLM messages ${addMessage}`,
+                search
+            ));
+        }
+    }
+
+    /**
+     *
+     * @param {LLMMessage[]} prompt
+     * @returns {string}
+     */
+    static promptStats (prompt) {
+        const stats = prompt.reduce((o, m) => Object.assign(o, {
+            [m.role]: (o[m.role] || 0) + 1
+        }), {
+            system: 0, assistant: 0, user: 0, tool: 0
+        });
+
+        return `[ ${Object.entries(stats).map(([k, v]) => `${k.toUpperCase()}: ${v}`).join(' ')} ]`;
+    }
+
+    /**
+     *
+     * @param {LLMRole} role
+     * @return {string}
+     */
+    static _marker (role) {
+        switch (role) {
+            case 'user':
+                return '>';
+            case 'system':
+                return '*';
+            case 'assistant':
+                return '<';
+            default:
+                return '-';
+        }
+    }
+
+    static _content (msg, full) {
+        if (typeof msg.content !== 'string') {
+            return msg.content === null ? '<null>' : typeof msg.content;
+        }
+        const txt = msg.content.replace(/\n+/g, ' ').replace(/\s\s+/g, ' ');
+        return `'${txt.length <= 100 || full ? txt : `${txt.substring(0, 100)}...`}'`;
+    }
+
+    /**
+     *
+     * @param {PromptInfo[]} prompts
+     * @param {boolean} [full=false]
+     * @param {boolean} [silent=false]
+     * @returns {string[]}
+     */
+    static debug (prompts, full = false, silent = false) {
+        let out;
+        if (prompts.length === 0) {
+            out = ['no LLM prompts occured'];
+        } else {
+            out = prompts.map((p, i) => {
+                const lastIndexOfUser = full
+                    ? 0
+                    : p.prompt.reduce((li, m, c) => (m.role === 'user' ? c : li), 0);
+
+                const prompt = p.prompt.reduce((a, m, c) => {
+                    if (['user', 'assistant'].includes(m.role) && c < lastIndexOfUser) {
+                        const prev = a[a.length - 1];
+                        if (prev === '...') {
+                            return a;
+                        }
+                        return [...a, '...'];
+                    }
+                    return [...a, `${PromptAssert._marker(m.role)} ${PromptAssert._content(m, full)}`];
+                }, []);
+
+                return [
+                    `${i + 1}) ${PromptAssert.promptStats(p.prompt)}`,
+                    `${prompt.join('\n   ')}`,
+                    `# ${PromptAssert._content(p.result)}`
+                ].join('\n   ');
+            });
+        }
+        if (!silent) {
+            // eslint-disable-next-line no-console
+            console.log(...out);
+        }
+        return out;
+    }
+
+}
+
+module.exports = PromptAssert;

package/src/testTools/asserts.js

@@ -7,6 +7,9 @@ const assert = require('assert');
 const deepExtend = require('deep-extend');
 const { actionMatches, parseActionPayload } = require('../utils');
 
+/** @typedef {import('../LLM').PromptInfo} PromptInfo */
+/** @typedef {import('../LLM').LLMMessage} LLMMessage */
+
 /**
  * Format message
  *
@@ -29,9 +32,21 @@ function m (text, actual = null, expected = null) {
     return `${text}${result}`;
 }
 
-function ex (message, expected, actual) {
-    const actuals = Array.isArray(actual) ? actual : [actual];
-    return `${message}\n  + expected: "${expected}"\n  - actual:   ${actuals
+function ex (message, expected, actual = null) {
+    let actuals;
+    if (Array.isArray(actual)) {
+        actuals = actual;
+    } else {
+        actuals = actual === null ? [] : [actual];
+    }
+
+    const msg = `${message}\n  + expected: "${expected}"`;
+
+    if (actuals.length === 0) {
+        return msg;
+    }
+
+    return `${msg}\n  - actual:   ${actuals
         .map((a) => `"${a}"`).join('\n              ')}`;
 }
 
@@ -144,6 +159,28 @@ function contains (response, search, message = 'Should contain a text') {
     return true;
 }
 
+/**
+ *
+ * @param {LLMMessage} llmMsg
+ * @param {string} search
+ * @param {string|false} message
+ */
+function llmContains (llmMsg, search, message = 'Should contain a text') {
+    const text = llmMsg.content;
+
+    const typeIsText = typeof text === 'string';
+    if (message === false && !typeIsText) {
+        return false;
+    }
+    assert.ok(typeIsText, m(message, search, 'not a text message'));
+    const match = searchMatchesText(search, text);
+    if (message === false) {
+        return match;
+    }
+    assert.ok(match, m(message, text, search));
+    return true;
+}
+
 /**
  * Checks quick response action
  *
@@ -374,5 +411,6 @@ module.exports = {
     quickReplyText,
     getText,
     parseActionPayload,
-    ex
+    ex,
+    llmContains
 };

package/src/utils/customCondition.js

@@ -175,9 +175,22 @@ const compare = (variable, operator, value = undefined) => {
     }
 };
 
+/** @typedef {'if'|'it'|'c'|'nc'|'mr'|'nmr'|'st'|'gt'|'set'|'get'|'eq'|'neq'} ConditionOperator */
+
+/**
+ * @typedef {object} EditableConditionRule
+ * @prop {string} value
+ * @prop {ConditionOperator} operator
+ * @prop {string} variable
+ */
+
+/**
+ * @typedef {EditableConditionRule[][]} EditableCondition
+ */
+
 /**
  *
- * @param {{value:string, operator:string, variable:string}[][]} condition
+ * @param {EditableCondition} condition
  * @param {object} configuration
  * @param {string} description
  */

package/src/utils/getCondition.js

@@ -7,11 +7,23 @@ const customCondition = require('./customCondition');
 const customFn = require('./customFn');
 
 /** @typedef {import('../BuildRouter').BotContext} BotContext */
+/** @typedef {import('./customCondition').EditableCondition} EditableCondition */
+
+// eslint-disable-next-line max-len
+/** @typedef {Pick<BotContext,'configuration'|'allowForbiddenSnippetWords'|'linksMap'|'ai'>} ConditionContext */
+
+/**
+ * @typedef {object} ConditionDefinition
+ * @prop {boolean} [hasCondition]
+ * @prop {string} [conditionFn]
+ * @prop {boolean} [hasEditableCondition]
+ * @prop {EditableCondition} [editableCondition]
+ */
 
 /**
  *
- * @param {object} params
- * @param {BotContext} context
+ * @param {ConditionDefinition} params
+ * @param {ConditionContext} context
  * @param {string} description
  * @returns {Function}
  */
@@ -27,7 +39,7 @@ module.exports = function getCondition (params, context, description = '') {
         editableCondition = []
     } = params;
 
-    let condition = null;
+    let condition;
 
     if (hasCondition) {
         if (hasEditableCondition) {
@@ -36,7 +48,7 @@ module.exports = function getCondition (params, context, description = '') {
             condition = customFn(conditionFn, description, allowForbiddenSnippetWords);
         }
     } else {
-        condition = customFn('(req,res)=>true', description, allowForbiddenSnippetWords);
+        condition = () => true;
     }
     return condition;
 };

package/src/utils/getUpdate.js

@@ -88,7 +88,7 @@ function toArray (previousValue) {
 const ENTITY_HBS_REGEXP = /^\s*\{\{\[?@([^@[\]{}\s]+)(\])?\}\}\s*$/;
 const VARIABLE_HBS_REGEXP = /^\s*\{\{\[?([^$@[\]{}\s]+)\]?\}\}\s*$/;
 
-function getSetState (setState, req, res = null, useState = null, configuration = null) {
+function getSetState (setState, req, res = null, stateOverride = null, configuration = null) {
     if (!setState) {
         return {};
     }
@@ -96,7 +96,7 @@ function getSetState (setState, req, res = null, useState = null, configuration
         .filter((k) => k !== '_');
 
     let obj = {};
-    let state = stateData(req, res, configuration, useState);
+    let state = stateData(req, res, configuration, stateOverride);
 
     keys.forEach((k) => {
         const val = setState[k];
@@ -166,8 +166,8 @@ function getSetState (setState, req, res = null, useState = null, configuration
                     if (entity && (!rear || req.entities.some((e) => e.entity === entity))) {
                         values = req.entities.filter((e) => e.entity === entity)
                             .map((e) => e.value);
-                        if (values.length === 0 && useState && useState[`@${entity}`]) {
-                            values = [useState[`@${entity}`]];
+                        if (values.length === 0 && stateOverride && stateOverride[`@${entity}`]) {
+                            values = [stateOverride[`@${entity}`]];
                         }
                     } else if (variable) {
                         values = toArray(getValue(variable, state));

package/src/utils/stateData.js

@@ -16,6 +16,7 @@ const { dateToISO8601String, zeroHourDate } = require('./datetime');
  * @prop {object} [configuration]
  * @prop {Function} text
  * @prop {Function} [actionData]
+ * @prop {Function} [isConfidentInput]
  */
 
 /**
@@ -68,6 +69,7 @@ module.exports = function stateData (
         $today,
         $tomorrow,
         $yesterday,
+        $llmResult: res?.llm?.lastResult?.content,
         // yes - res because of circular dependency
         ...(res && req && req.actionData()),
         ...(res ? res.data : {}),