wingbot 3.74.8 → 3.75.9-alpha.1

package/src/Responder.js

@@ -45,6 +45,7 @@ const EXCEPTION_HOPCOUNT_THRESHOLD = 5;
 /** @typedef {import('./LLMSession').LLMMessageSrc} LLMMessageSrc */
 /** @typedef {import('./LLMSession').AsyncLLMMessage} AsyncLLMMessage */
 /** @typedef {import('./utils/stateData').IStateRequest} IStateRequest */
+/** @typedef {import('./BuildRouter').BounceAllow} BounceAllow */
 
 /**
  * @enum {string} ExpectedInput
@@ -371,21 +372,32 @@ class Responder {
     /**
      *
      * @param {string} contextType
-     * @returns {Promise<LLMSession>}
+     * @param {LLMCallPreset} [callPreset]
+     * @returns {LLMSession}
      */
-    async llmSession (contextType = this.LLM_CTX_DEFAULT) {
+    llmSession (contextType = this.LLM_CTX_DEFAULT, callPreset = undefined) {
         const system = this._getSystemMessagesForType(contextType);
 
         const filters = this._filtersForContext(contextType);
-        return new LLMSession(this.llm, [system], this._llmSend.bind(this), filters);
+        return new LLMSession(this.llm, [system], {
+            onSend: this._llmSend.bind(this),
+            filters,
+            preset: callPreset,
+            res: this
+        });
     }
 
     /**
      *
+     * @param {LLMCallPreset} callPreset
      * @returns {LLMSession}
      */
-    llmSessionEmpty () {
-        return new LLMSession(this.llm, [], this._llmSend.bind(this));
+    llmSessionEmpty (callPreset) {
+        return new LLMSession(this.llm, [], {
+            onSend: this._llmSend.bind(this),
+            preset: callPreset,
+            res: this
+        });
     }
 
     /**
@@ -493,7 +505,12 @@ class Responder {
         return new LLMSession(this.llm, [
             this._getSystemMessagesForType(contextType),
             this._getTranscriptMessages(transcriptLength, transcriptFlag, transcriptAnonymize)
-        ], this._llmSend.bind(this), filters);
+        ], {
+            onSend: this._llmSend.bind(this),
+            filters,
+            preset: callPreset,
+            res: this
+        });
     }
 
     async _getTranscriptMessages (transcriptLength, transcriptFlag, transcriptAnonymize) {
@@ -524,6 +541,7 @@ class Responder {
     _llmSend (messages, quickReplies) {
         this.setFlag(LLM.GPT_FLAG);
 
+        // @ts-ignore
         const { persona } = this.llm.configuration;
 
         if (typeof persona === 'string') {
@@ -1183,9 +1201,10 @@ class Responder {
      *
      * @param {string} action - desired action
      * @param {object} data - desired action data
+     * @param {BounceAllow} bounce
      * @returns {this}
      */
-    expected (action, data = {}) {
+    expected (action, data = {}, bounce = null) {
         if (!action) {
             return this.setState({ _expected: null });
         }
@@ -1193,7 +1212,8 @@ class Responder {
         return this.setState({
             _expected: {
                 action: makeAbsolute(action, this.path),
-                data
+                data,
+                bounce
             }
         });
     }

package/src/Router.js

@@ -6,8 +6,11 @@
 const { pathToRegexp } = require('path-to-regexp');
 const ReducerWrapper = require('./ReducerWrapper');
 const { makeAbsolute } = require('./utils');
+const GlobalIntents = require('./GlobalIntents');
 
 /** @typedef {import('./Responder')} Responder */
+/** @typedef {import('./LLMDispatcher').Routing} Routing */
+/** @typedef {import('./GlobalIntents').GlobalIntentResolved} GlobalIntentResolved */
 
 /**
  * @template {object} [S=object]
@@ -52,7 +55,7 @@ function defaultPathContext () {
  * @param {Responder} [res]
  * @param {PostBack} [postBack]
  * @param {string} [path]
- * @returns {Promise<RoutingInstruction>}
+ * @returns {Promise<RoutingInstruction>|RoutingInstruction}
  */
 
 /**
@@ -93,6 +96,17 @@ function defaultPathContext () {
  * @prop {string} [gaApiSecret]
  */
 
+/**
+ * @template {BaseConfiguration} [C=object]
+ * @typedef {object} ResolvedReducer
+ * @prop {string} resolverPath
+ * @prop {boolean} isReducer
+ * @prop {Function} reduce
+ * @prop {Map<number, GlobalIntentResolved>} globalIntents
+ * @prop {object} globalIntentsMeta
+ * @prop {BaseConfiguration} configuration
+ */
+
 /**
  * Cascading router
  *
@@ -119,8 +133,6 @@ class Router extends ReducerWrapper {
             : configuration || {};
 
         this._routes = [];
-
-        this.globalIntents = new Map();
     }
 
     /**
@@ -202,29 +214,7 @@ class Router extends ReducerWrapper {
             path: pathContext.path
         });
 
-        reducers.forEach(({ globalIntents }) => {
-            for (const gi of globalIntents.values()) {
-                const {
-                    id, matcher, action: intentPath, local, title,
-                    entitiesSetState = {}, usedEntities, meta = {}
-                } = gi;
-                const action = intentPath === '/*'
-                    ? pathContext.path
-                    : `${pathContext.path}${intentPath}`.replace(/^\/\*/, '');
-
-                this.globalIntents.set(id, {
-                    id,
-                    matcher,
-                    usedEntities,
-                    entitiesSetState,
-                    action,
-                    localPath: pathContext.path,
-                    local,
-                    title,
-                    meta: { ...pathContext.globalIntentsMeta, ...meta }
-                });
-            }
-        });
+        GlobalIntents.mergeGlobalIntents(reducers, this.globalIntents, pathContext);
 
         return this;
     }
@@ -282,6 +272,11 @@ class Router extends ReducerWrapper {
         });
     }
 
+    /**
+     * @param {*} reducer
+     * @param {string} thePath
+     * @returns {ResolvedReducer}
+     */
     _createReducer (reducer, thePath) {
         let resolverPath = thePath;
         let reduce = reducer;

package/src/Tester.js

@@ -18,13 +18,15 @@ 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');
 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 */
+/** @typedef {import('./LLM').LLMPresetName} LLMPresetName */
+/** @typedef {import('./LLMMockProvider').LLMMockResponse} LLMMockResponse */
+/** @typedef {import('./LLMMockProvider').LLMRoutingResponse} LLMRoutingResponse */
 
 /**
  * Utility for testing requests
@@ -106,7 +108,6 @@ class Tester {
             // @ts-ignore
             loadUsers: false,
             llm: {
-                provider: new LLMMockProvider(),
                 ...processorOptions.llm
             },
             ...processorOptions
@@ -497,6 +498,46 @@ class Tester {
         return this.processMessage(Request.intent(this.senderId, intent, score));
     }
 
+    /**
+     *
+     * @param {string} text
+     * @param {string|object} routingMock
+     * @param {(string|object)[]} [defaultMocks]
+     * @returns {Promise}
+     */
+    llm (text, routingMock = text, ...defaultMocks) {
+        const routingMocks = this._makeLLMMocks('routing', [
+            typeof routingMock === 'string' ? { action: routingMock } : routingMock
+        ]);
+        const llmMocks = this._makeLLMMocks('default', defaultMocks);
+        const req = Request.llm(this.senderId, text, [...routingMocks, ...llmMocks]);
+        return this.processMessage(req);
+    }
+
+    /**
+     *
+     * @param {LLMPresetName} preset
+     * @param {(string|object)[]} mocks
+     * @returns {LLMMockResponse[]}
+     */
+    _makeLLMMocks (preset, mocks) {
+        return mocks.map((content) => ({
+            preset, content
+        }));
+    }
+
+    // /**
+    //  *
+    //  * @param {string} text
+    //  * @param {(string|object)[]} [defaultMocks]
+    //  * @returns {Promise}
+    //  */
+    // llm (text, ...defaultMocks) {
+    //     const llmMocks = this._makeLLMMocks('default', defaultMocks);
+    //     const req = Request.llm(this.senderId, text, llmMocks);
+    //     return this.processMessage(req);
+    // }
+
     /**
      * Makes recognised AI intent request with entity
      *

package/src/prompt.js

@@ -0,0 +1,138 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+const hbs = require('handlebars');
+const stateData = require('./utils/stateData');
+
+/** @typedef {import('./Request')} Request */
+/** @typedef {import('./Responder')} Responder */
+
+/**
+ * @callback Renderer
+ * @param {object|Request} req
+ * @param {Responder} [res]
+ * @returns {Promise<string>}
+ */
+
+/** @typedef {Renderer} Prompt */
+
+/**
+ * @typedef {string|number} TemplateValue
+ */
+
+/**
+ * @typedef {TemplateValue|object} ReturnValue
+ */
+
+/**
+ * @callback ExecutableInput
+ * @param {object} data
+ * @returns {Promise<ReturnValue>|ReturnValue}
+ */
+
+/**
+ * @typedef {ExecutableInput|TemplateValue|object} Input
+ */
+
+let uq = 0;
+
+const LEFT_HBS = /\{\{[^}]*$/;
+const RIGHT_HBS = /^[^{]*\}\}/;
+
+const insideHbs = (left, right) => LEFT_HBS.exec(left) && RIGHT_HBS.exec(right);
+
+/**
+ *
+ * @param {TemplateStringsArray} strings
+ * @param {...Input} args
+ * @returns {Prompt}
+ */
+function prompt (strings, ...args) {
+    const prefix = `_t_${uq++}_`;
+    const argKey = (n) => `${prefix}${n}`;
+
+    const inputData = {};
+
+    let executeOnce = [];
+    const executeRepeatedly = [];
+
+    let result = strings[0];
+    for (let i = 0, l = args.length; i < l; i++) {
+        const key = argKey(i);
+        const arg = args[i];
+        const isScalar = typeof arg === 'string'
+            || typeof arg === 'number';
+
+        if (!isScalar) {
+            if (typeof arg !== 'function') {
+                inputData[key] = arg;
+            } else if (arg.length) {
+                executeRepeatedly.push([key, arg]);
+            } else {
+                executeOnce.push([key, arg]);
+            }
+        }
+
+        if (insideHbs(strings[0], strings[i + 1])) {
+            if (isScalar) {
+                result += (typeof arg === 'string' ? `'${arg.replace(/'/g, '\\\'')}'` : arg)
+                    + strings[i + 1];
+            } else {
+                result += key + strings[i + 1];
+            }
+        } else if (isScalar) {
+            result += `${arg}${strings[i + 1]}`;
+        } else {
+            result += `{{{${key}}}}${strings[i + 1]}`;
+        }
+    }
+    const precompiled = hbs.compile(result);
+    let oncePromise = null;
+
+    const renderer = async (req, res = null) => {
+        const reqIsRequest = 'action' in req && typeof req.action === 'function';
+        const data = {
+            ...(reqIsRequest ? stateData(req, res) : req),
+            ...inputData
+        };
+
+        if (executeOnce.length || executeRepeatedly.length) {
+            if (!oncePromise) {
+                oncePromise = executeOnce.map(async ([key, val]) => {
+                    const useVal = await val();
+                    inputData[key] = useVal;
+                    return [key, useVal];
+                });
+            }
+
+            const resulted = await Promise.all([
+                ...oncePromise,
+                ...executeRepeatedly.map(async ([key, val]) => {
+                    const useVal = await val(data);
+                    return [key, useVal];
+                })
+            ])
+                .then((r) => {
+                    executeOnce = [];
+                    return r;
+                })
+                .finally(() => {
+                    oncePromise = null;
+                });
+
+            Object.assign(data, Object.fromEntries(resulted));
+        }
+
+        return precompiled(data);
+    };
+
+    Object.assign(renderer, {
+        toString: () => result
+    });
+
+    return renderer;
+}
+
+module.exports = prompt;

package/src/resolvers/bounce.js

@@ -8,8 +8,10 @@
  */
 const BOUNCE_ALLOW = {
     NOT_ALLOWED: null,
-    ALLOWED_TO_FAQ: 'faq',
-    ALLOWED: 'allow'
+    ALLOWED_TO_FAQ: 'faq', // let it deprecate
+    ALLOWED: 'allow' // when something's detected, allow move, otherwise?
+
+    // lets deal with implicit expected - put it into the router above (enabled in specific context)
 };
 
 /**

package/src/resolvers/expected.js

@@ -5,19 +5,20 @@
 
 const Router = require('../Router');
 
-function expected ({ path, attachedRouter }, { isLastIndex }) {
+function expected ({ path, attachedRouter }, { isLastIndex, bounceAllowedTo }) {
 
     if (attachedRouter) {
         return (req, res, postBack) => postBack(path, {
             _useExpected: {
                 action: res.toAbsoluteAction(path),
-                data: {}
+                data: {},
+                bounceAllowedTo
             }
         }, true);
     }
 
     return (req, res) => {
-        res.expected(path);
+        res.expected(path, {}, bounceAllowedTo);
 
         return isLastIndex ? Router.END : Router.CONTINUE;
     };

package/src/tools/routeToEvents.js

@@ -39,6 +39,7 @@ async function routeToEvents (pageId, senderId, state, resolvers) {
 
     const req = new Request(event, state, pageId);
     const res = new Responder(senderId, returnSender);
+    await req.dispatcher.dispatch(req, res);
 
     Object.assign(res, {
         subscribe (tag) { subscribe.push(tag); },

package/src/wingbot/CustomEntityDetectionModel.js

@@ -41,7 +41,7 @@ const { iterateThroughWords } = require('../utils/ai');
 /**
  * @typedef {object} Intent
  * @prop {string} intent
- * @prop {number} score
+ * @prop {number} [score]
  * @prop {Entity[]} [entities]
  */
 

package/.claude/settings.local.json

@@ -1,8 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npx mocha:*)",
-      "Bash(npx tsc *)"
-    ]
-  }
-}