wingbot 3.71.6 → 3.72.1

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) {

package/src/Tester.js

@@ -19,8 +19,12 @@ 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');
+const PromptAssert = require('./testTools/PromptAssert');
 
 /** @typedef {import('./Processor').ProcessorOptions<Router>} ProcessorOptions */
+/** @typedef {import('./LLM').PromptInfo} PromptInfo */
+/** @typedef {import('./LLM').LLMRole} LLMRole */
+/** @typedef {import('./LLM').LLMMessage} LLMMessage */
 
 /**
  * Utility for testing requests
@@ -128,6 +132,9 @@ class Tester {
         this.responses = [];
         this.actions = [];
 
+        /** @type {PromptInfo[]} */
+        this.prompts = [];
+
         /**
          * @prop {object} predefined test data to use
          */
@@ -201,6 +208,7 @@ class Tester {
         this._actionsCollector = [];
         this._pluginBlocksCollector = [];
         this._responsesMock = [];
+        this.prompts = [];
     }
 
     /**
@@ -259,6 +267,7 @@ class Tester {
             throw Object.assign(new Error(`Processor failed with status ${res.status}`), { code: res.status });
         }
         this.responses = messageSender.responses;
+        this.prompts = messageSender.prompts;
         this.pluginBlocks = this._pluginBlocksCollector;
         this.actions = this._actionsCollector;
         this._actionsCollector = [];
@@ -388,6 +397,36 @@ class Tester {
         this.storage.saveState(stateObj);
     }
 
+    /**
+     *
+     * @returns {PromptAssert}
+     */
+    anyPrompt () {
+        return new PromptAssert(this.prompts);
+    }
+
+    /**
+     *
+     * @returns {PromptAssert}
+     */
+    lastPrompt () {
+        return new PromptAssert(
+            this.prompts.length
+                ? [this.prompts[this.prompts.length - 1]]
+                : []
+        );
+    }
+
+    /**
+     *
+     * @returns {LLMMessage}
+     */
+    getLastPromptResult () {
+        return this.prompts.length
+            ? this.prompts[this.prompts.length - 1].result
+            : null;
+    }
+
     /**
      * Assert, that state contains a subset of provided value
      *
@@ -606,9 +645,10 @@ class Tester {
     /**
      * Prints last conversation turnaround
      *
-     * @param {boolean} [showPrivateKeys]
+     * @param {boolean} [full=false]
+     * @param {boolean} [showPrivateKeys=false]
      */
-    debug (showPrivateKeys = false) {
+    debug (full = false, showPrivateKeys = false) {
         // eslint-disable-next-line no-console
         console.log(
             '\n===== actions =====\n',
@@ -625,6 +665,8 @@ class Tester {
                 Object.entries(this.getState().state)
                     .filter((e) => showPrivateKeys || !e[0].startsWith('_'))
             ),
+            '\n------- LLM -------\n',
+            ...PromptAssert.debug(this.prompts, full, true),
             '\n===================\n'
         );
     }

package/src/graphApi/GraphApi.js

@@ -8,6 +8,7 @@ const WingbotApiConnector = require('./WingbotApiConnector');
 // @ts-ignore
 const packageJson = require('../../package.json');
 const headersToAuditMeta = require('../utils/headersToAuditMeta');
+const gqlRules = require('./gqlRules');
 
 const DEFAULT_GROUPS = ['botEditor', 'botAdmin', 'appToken'];
 const KEYS_URL = 'https://api.wingbot.ai/keys';
@@ -27,6 +28,12 @@ const DEFAULT_CACHE = 86400000; // 24 hours
 /** @typedef {import('../CallbackAuditLog')} AuditLog */
 /** @typedef {import('graphql')} GqlLib */
 
+/**
+ * @typedef {object} Logger
+ * @prop {Function} log
+ * @prop {Function} error
+ */
+
 /**
  * Experimental chatbot API
  */
@@ -41,8 +48,11 @@ class GraphApi {
      * @param {string[]} [options.groups] - list of allowed bot groups
      * @param {boolean} [options.useBundledGql] - uses library bundled graphql definition
      * @param {AuditLog} [options.auditLog]
+     * @param {boolean} [options.isProduction]
+     * @param {boolean} [options.hideVerboseErrors]
+     * @param {Logger} [log=console]
      */
-    constructor (apis, options) {
+    constructor (apis, options, log = console) {
         this._root = {
             version () {
                 return packageJson.version;
@@ -65,6 +75,13 @@ class GraphApi {
             }
         };
 
+        this._log = log;
+        this._options = {
+            hideVerboseErrors: true,
+            isProduction: true,
+            ...options
+        };
+
         Object.assign(opts, options);
 
         apis.forEach((api) => Object.assign(this._root, api));
@@ -152,6 +169,19 @@ class GraphApi {
 
         const schema = await this._schema();
 
+        const { isProduction = true, hideVerboseErrors } = this._options;
+        const ast = this._gql.parse(body.query);
+        const errors = this._gql.validate(
+            schema,
+            ast,
+            gqlRules(body.variables, isProduction, hideVerboseErrors, this._log)
+        );
+
+        if (errors.length > 0) {
+            this._log.error('GQL failed', errors);
+            return { errors };
+        }
+
         const ctx = {
             token,
             groups: this._defaultGroups,

package/src/graphApi/gqlRules.js

@@ -0,0 +1,87 @@
+/* eslint-disable global-require */
+/**
+ * @author David Menger
+ */
+'use strict';
+
+/** @typedef {import('graphql').ValidationRule} ValidationRule */
+
+/**
+ * @typedef {object} Logger
+ * @prop {Function} log
+ * @prop {Function} error
+ */
+
+/**
+ *
+ * @param {object} variables
+ * @param {boolean} isProduction
+ * @param {boolean} hideVerboseErrors
+ * @param {Logger} [log=console]
+ * @returns {ValidationRule[]}
+ */
+function gqlRules (variables, isProduction, hideVerboseErrors, log = console) {
+    // OPTIMIZATION FOR LAMBDA PERFORMANCE
+    const { GraphQLError, NoSchemaIntrospectionCustomRule } = require('graphql');
+    const { createComplexityRule, simpleEstimator } = require('graphql-query-complexity');
+    const depthLimit = require('graphql-depth-limit');
+
+    return [
+        ...(hideVerboseErrors ? [NoSchemaIntrospectionCustomRule] : []),
+        depthLimit(10),
+        createComplexityRule({
+            // The maximum allowed query complexity, queries above this threshold will be rejected
+            maximumComplexity: 1000,
+
+            // The query variables. This is needed because the variables are not available
+            // in the visitor of the graphql-js library
+            variables,
+
+            // The context object for the request (optional)
+            context: {},
+
+            // The maximum number of query nodes to evaluate (fields, fragments, composite types).
+            // If a query contains more than the specified number of nodes, the complexity rule will
+            // throw an error, regardless of the complexity of the query.
+            //
+            // Default: 10_000
+            maxQueryNodes: 10000,
+
+            // Optional callback function to retrieve the determined query complexity
+            // Will be invoked whether the query is rejected or not
+            // This can be used for logging or to implement rate limiting
+            onComplete: (complexity) => {
+                if (!isProduction) {
+                    log.log('Determined query complexity: ', complexity);
+                }
+            },
+
+            // Optional function to create a custom error
+            createError: (max, actual) => {
+                const msg = `GQL Query too complex: ${actual}. Maximum allowed: ${max}`;
+
+                if (hideVerboseErrors) {
+                    log.error(msg);
+                    return new GraphQLError('');
+                }
+                log.log(msg);
+                return new GraphQLError(`Query is too complex: ${actual}. Maximum allowed complexity: ${max}`);
+            },
+
+            // Add any number of estimators. The estimators are invoked in order, the first
+            // numeric value that is being returned by an estimator is used as the field complexity.
+            // If no estimator returns a value, an exception is raised.
+            estimators: [
+                // Add more estimators here...
+
+                // This will assign each field a complexity of 1 if no other estimator
+                // returned a value.
+                simpleEstimator({
+                    defaultComplexity: 1
+                })
+            ]
+        })
+    ];
+}
+
+module.exports = gqlRules;

package/src/graphApi/schema.gql

@@ -109,9 +109,24 @@ type LLMMessage {
     toolCalls: [ToolCall!]
 }
 
+type VectorSearchDocument {
+  id: String!
+  name: String!
+  text: String!
+  cosineDistance: Float!
+  excludedByCosineDistanceThreshold: Boolean!
+}
+
+type VectorSearchResult {
+  maximalCosineDistanceThreshold: Float! 
+  nearestNeighbourCount: Int!
+  resultDocuments: [VectorSearchDocument!]!  
+}
+
 type PromptInfo {
     prompt: [LLMMessage!]!
     result: LLMMessage!
+    vectorSearchResult: VectorSearchResult
 }
 
 type UserInteraction {