wingbot 3.75.9-alpha.6 → 3.76.1-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.75.9-alpha.6",
+  "version": "3.76.1-alpha.1",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "type": "commonjs",
@@ -39,7 +39,7 @@
   "homepage": "https://github.com/wingbot.ai/wingbot#readme",
   "devDependencies": {
     "@types/mocha": "^10.0.10",
-    "@wingbotai/wingbot-ai-orchestrator": "^2.13.3",
+    "@wingbotai/wingbot-ai-orchestrator": "^2.13.4",
     "cpy-cli": "^5.0.0",
     "eslint": "^8.56.0",
     "eslint-config-airbnb": "^19.0.4",

package/src/BuildRouter.js

@@ -12,19 +12,46 @@ const path = require('path');
 const Router = require('./Router');
 const Plugins = require('./Plugins');
 const Ai = require('./Ai');
+const LLMRouter = require('./LLMRouter');
 const expected = require('./resolvers/expected');
 const bounce = require('./resolvers/bounce');
 const { cachedTranslatedCompilator } = require('./resolvers/utils');
 const defaultResourceMap = require('./defaultResourceMap');
 const { shouldExecuteResolver } = require('./resolvers/resolverTags');
+const getCondition = require('./utils/getCondition');
+const compileWithState = require('./utils/compileWithState');
 
 const MESSAGE_RESOLVER_NAME = 'botbuild.message';
 const PLUGIN_RESOLVER_NAME = 'botbuild.customCode';
 
+const designerApiUrl = process.env.DESIGNER_API_URL || 'https://api.wingbot.ai';
+
 /** @typedef {import('./resolvers/bounce').BounceAllow} BounceAllow */
 /** @typedef {import('./resolvers/bounce').BounceReturn} BounceReturn */
+/** @typedef {import('./LLMRouter').RouteCondition} RouteCondition */
+/** @typedef {import('./utils/getCondition').ConditionDefinition} ConditionDefinition */
+/** @typedef {import('./utils/customCondition').EditableCondition} EditableCondition */
 
 /** @typedef {import('./Router').BaseConfiguration} BaseConfiguration */
+/** @typedef {'global'|'local'} LLMRoutingScope */
+/** @typedef {'fallback'|'keepAllow'} BlockLlmRoutingBounce */
+
+/**
+ * @typedef {ConditionDefinition & {
+ *   scope?: LLMRoutingScope,
+ *   classificationDescription?: string,
+ *   editableCondition?: EditableCondition
+ * }} RouteLlmRouting
+ */
+
+/**
+ * @typedef {{
+ *   prompt?: string,
+ *   scope?: LLMRoutingScope,
+ *   bounce?: BlockLlmRoutingBounce
+ * }} BlockLlmRouting
+ */
+
 /**
  * @typedef {object} BuildInfo
  * @prop {boolean} [expectedToAddResolver]
@@ -65,6 +92,7 @@ const PLUGIN_RESOLVER_NAME = 'botbuild.customCode';
  * @prop {BounceAllow} [bounceAllowedTo]
  * @prop {BounceReturn} [bounceReturn]
  * @prop {boolean} [isEntryPoint]
+ * @prop {RouteLlmRouting} [llmRouting]
  */
 
 /**
@@ -93,6 +121,7 @@ const DUMMY_ROUTE = { id: 0, path: null, resolvers: [] };
  * @prop {boolean} [disabled]
  * @prop {string} [blockName]
  * @prop {string} [blockType]
+ * @prop {BlockLlmRouting} [llmRouting]
  */
 
 /**
@@ -173,6 +202,7 @@ const DUMMY_ROUTE = { id: 0, path: null, resolvers: [] };
  * @prop {NestedLinksMapFactory} [nestedLinksMapFactory]
  * @prop {object} [BuildRouter]
  * @prop {Ai} [ai]
+ * @prop {LLMRouter} [llmRouter]
  * @prop {string|number} [resolverId] - only for text messages with random characters
  */
 
@@ -198,7 +228,7 @@ class BuildRouter extends Router {
      * @param {BotConfig|Block} block
      * @param {Plugins} plugins - custom code blocks resource
      * @param {BuildRouterContext<C>|Promise<BuildRouterContext<C>>} context - the building context
-     * @param {fetch} [fetchFn] - override a request function
+     * @param {typeof fetch} [fetchFn] - override a request function
      * @example
      *
      * // usage of plugins
@@ -291,7 +321,7 @@ class BuildRouter extends Router {
         } else if (typeof block.botId === 'string') {
             this._snapshot = block.snapshot || 'production';
             this._botId = block.botId;
-            this._loadBotUrl = `https://api.wingbot.ai/bots/${this._botId}/snapshots/${this._snapshot}/blocks`;
+            this._loadBotUrl = `${designerApiUrl}/bots/${this._botId}/snapshots/${this._snapshot}/blocks`;
         }
     }
 
@@ -614,8 +644,16 @@ class BuildRouter extends Router {
             blockName, blockType, isRoot, staticBlockId
         } = block;
 
+        const llmRouter = this._createBlockLlmRouter(block);
+
         this._resolvedContext = {
-            ...this._resolvedContext, blockName, blockType, isRoot, staticBlockId, BuildRouter
+            ...this._resolvedContext,
+            blockName,
+            blockType,
+            isRoot,
+            staticBlockId,
+            BuildRouter,
+            llmRouter
         };
 
         const [linksMap, nestedBlocksByStaticId] = this._createLinksMap(block);
@@ -623,6 +661,10 @@ class BuildRouter extends Router {
         this._linksMap = linksMap;
         this._nestedLinksMap = null;
 
+        if (llmRouter) {
+            this.use(llmRouter);
+        }
+
         // @ts-ignore
         this._buildRoutes(block.routes, nestedBlocksByStaticId);
 
@@ -816,6 +858,108 @@ class BuildRouter extends Router {
         });
     }
 
+    /**
+     * @param {Block} block
+     * @returns {LLMRouter|null}
+     */
+    _createBlockLlmRouter (block) {
+        const { llmRouting } = block;
+
+        if (!llmRouting || !llmRouting.prompt || !llmRouting.prompt.trim()) {
+            return null;
+        }
+
+        const routeResolver = LLMRouter.defaultRoute(
+            async (resolvedData) => compileWithState(null, null, llmRouting.prompt, resolvedData)
+        );
+        const options = llmRouting.bounce === 'keepAllow'
+            ? { keepUserInInteractionsWithBounceAllowed: true }
+            : {};
+
+        return llmRouting.scope === 'local'
+            ? new LLMRouter(routeResolver, options)
+            : LLMRouter.global(routeResolver, options);
+    }
+
+    /**
+     * @param {TransformedRoute} route
+     * @returns {RouteCondition|null}
+     */
+    _createLlmRouteCondition (route) {
+        const { llmRouting } = route;
+
+        if (!llmRouting || !llmRouting.hasCondition) {
+            return null;
+        }
+
+        // TODO: what if the configuration is promise? Is this the way to properly get rid of it?
+        /** @type {C} */
+        const configuration = this._configuration instanceof Promise
+            ? null
+            : this._configuration;
+
+        const condition = getCondition(llmRouting, {
+            ai: Ai.ai,
+            ...this._resolvedContext,
+            configuration,
+            linksMap: this._linksMap
+        }, `LLM routing condition "${route.path || route.id}"`);
+
+        return (state, req = null) => {
+            const useReq = req
+                ? Object.assign(Object.create(req), { state })
+                : {
+                    state,
+                    configuration,
+                    text: () => '',
+                    actionData: () => ({})
+                };
+
+            if (typeof useReq.text !== 'function') {
+                useReq.text = () => '';
+            }
+            if (typeof useReq.actionData !== 'function') {
+                useReq.actionData = () => ({});
+            }
+
+            return condition(useReq, null);
+        };
+    }
+
+    /**
+     * @param {TransformedRoute} route
+     * @returns {import('./GlobalIntents').MatchingResolver|null}
+     */
+    _createLlmRouteResolver (route) {
+        const { llmRouting } = route;
+
+        if (!llmRouting
+            || !llmRouting.classificationDescription
+            || !llmRouting.classificationDescription.trim()) {
+            return null;
+        }
+
+        /** @type {import('./LLMRouter').RouteOptions} */
+        const options = {};
+        const condition = this._createLlmRouteCondition(route);
+
+        if (condition) {
+            options.condition = condition;
+        }
+
+        if (llmRouting.scope === 'local') {
+            const { llmRouter } = this._resolvedContext;
+
+            if (!llmRouter) {
+                throw new Error(`Local LLM routing requires block.llmRouting prompt on block "${this._resolvedContext.blockName || ''}"`);
+            }
+
+            return llmRouter.route(route.path, llmRouting.classificationDescription, options);
+        }
+
+        return LLMRouter.route(route.path, llmRouting.classificationDescription, options);
+    }
+
     /**
      *
      * @param {TransformedRoute} route
@@ -829,8 +973,9 @@ class BuildRouter extends Router {
 
         if (!route.isFallback) {
             let aiResolver = null;
+            const llmResolver = this._createLlmRouteResolver(route);
 
-            if (route.aiTags && route.aiTags.length) {
+            if (!llmResolver && route.aiTags && route.aiTags.length) {
                 let aiTitle = null;
 
                 if (route.aiTitle) {
@@ -846,7 +991,9 @@ class BuildRouter extends Router {
                 }
             }
 
-            if (aiResolver && route.isResponder) {
+            if (llmResolver) {
+                resolvers.push(llmResolver);
+            } else if (aiResolver && route.isResponder) {
                 resolvers.push(route.path, aiResolver);
             } else if (aiResolver) {
                 resolvers.push(aiResolver);

package/src/ChatGpt.js

@@ -31,6 +31,7 @@ const LLM = require('./LLM');
  * @prop {string} [apiVersion]
  * @prop {string} [apiKey] // for microsoft services
  * @prop {string} [authorization] // for chat gpt api
+ * @prop {number} [timeout=15000] - request timeout in ms; set to 0 to disable
  */
 
 /** @typedef {'gpt-3.5-turbo'|'gpt-4'|'gpt-4-32k'|'gpt-3.5-turbo-16k'|string} ChatGPTModel */
@@ -189,11 +190,13 @@ class ChatGpt {
             openAiEndpoint = 'https://api.openai.com/v1',
             apiKey,
             authorization,
+            timeout = 15000,
             ...rest
         } = options;
 
         this._apiKey = apiKey;
         this._authorization = authorization;
+        this._timeout = timeout;
 
         this._fetch = fetch;
 
@@ -446,14 +449,19 @@ class ChatGpt {
                         ? { 'api-key': this._apiKey }
                         : { Authorization: `Bearer ${this._authorization}` })
                 },
-                body: JSON.stringify(body)
+                body: JSON.stringify(body),
+                ...(this._timeout > 0 ? { timeout: this._timeout } : {})
             });
 
             ({ status, statusText } = response);
 
             responseText = await response.text();
             /** @type {ChatGPTResponse} */
-            responseData = JSON.parse(responseText);
+            try {
+                responseData = JSON.parse(responseText);
+            } catch {
+                throw new Error(`Chat GPT ${status} (non-JSON): ${responseText.slice(0, 200)}`);
+            }
 
             if (status !== 200
                 || !Array.isArray(responseData.choices)) {

package/src/GlobalIntents.js

@@ -8,6 +8,7 @@
 /** @typedef {import('./AiMatching').Entity} Entity */
 /** @typedef {import('./LLMDispatcher').ILLMRouter} ILLMRouter */
 /** @typedef {import('./LLMRouter').GILLMExtension} GILLMExtension */
+/** @typedef {import('./LLMRouter').RouteCondition} RouteCondition */
 
 let uq = 1;
 
@@ -39,6 +40,7 @@ let uq = 1;
  * @prop {object} [meta]
  * @prop {string} [classification]
  * @prop {ILLMRouter} [router]
+ * @prop {RouteCondition} [condition]
  */
 
 /**
@@ -124,6 +126,7 @@ class GlobalIntents {
             meta = {},
             classification = null,
             router = null,
+            condition = null,
             local = false,
             keepUserInInteractionsWithBounceAllowed
         } = {},
@@ -140,6 +143,7 @@ class GlobalIntents {
             meta,
             classification,
             router,
+            condition,
             ...(typeof keepUserInInteractionsWithBounceAllowed === 'boolean'
                 ? { keepUserInInteractionsWithBounceAllowed }
                 : {}
@@ -165,7 +169,7 @@ class GlobalIntents {
                 const {
                     id, matcher = null, action: intentPath, local, title,
                     entitiesSetState = {}, usedEntities, meta = {},
-                    classification = null, router = null,
+                    classification = null, router = null, condition = null,
                     keepUserInInteractionsWithBounceAllowed,
                     localPath: prevLocalPath
                 } = gi;
@@ -208,6 +212,7 @@ class GlobalIntents {
                     title,
                     classification,
                     router,
+                    condition,
                     meta: { ...pathContext.globalIntentsMeta, ...meta },
                     ...(typeof keepUserInInteractionsWithBounceAllowed === 'boolean'
                         ? { keepUserInInteractionsWithBounceAllowed }

package/src/LLMDispatcher.js

@@ -72,10 +72,11 @@ class LLMDispatcher {
             nlpMatchers: [],
             giByAction: new Map(),
             globals: {
-                actionListString: null,
+                actionListString: '',
                 actionList: [],
                 router: null,
-                byAction: new Map()
+                byAction: new Map(),
+                routes: []
             },
             locals: new Map()
         };
@@ -223,8 +224,8 @@ class LLMDispatcher {
 
     /**
      *
-     * @param {*} state
-     * @returns {LLMRoutingCache}
+     * @param {{lastAction?: string | null}} state
+     * @returns {LLMRoutingCache|null}
      */
     _localLLmRoutingForState (state) {
         const { lastAction } = state;
@@ -251,6 +252,26 @@ class LLMDispatcher {
             return null;
         }
 
+        const filteredRoutes = routing.routes
+            .filter(({ condition }) => !condition || condition(state, this._req));
+
+        if (filteredRoutes.length === 0) {
+            return {
+                ...routing,
+                actionList: [],
+                actionListString: '',
+                byAction: new Map(),
+                router
+            };
+        }
+
+        if (filteredRoutes.length !== routing.routes.length) {
+            return {
+                ...LLMRouter._prepareRoutingInput(filteredRoutes),
+                router
+            };
+        }
+
         return {
             ...routing,
             router

package/src/LLMRouter.js

@@ -17,6 +17,13 @@ const LLMType = require('./LLMType');
 /** @typedef {import('./prompt').Prompt} Prompt */
 /** @typedef {import('./Router').RoutingInstruction} RoutingInstruction */
 
+/**
+ * @callback RouteCondition
+ * @param {object} state
+ * @param {Request} [req]
+ * @returns {boolean}
+ */
+
 /**
  * @typedef {object} NLPActionInfo
  * @prop {MatcherResult} intent
@@ -69,6 +76,12 @@ const LLMType = require('./LLMType');
  * @prop {LLMAction[]} actionList
  * @prop {ILLMRouter|null} router
  * @prop {Map<string, GlobalIntentResolved>} byAction
+ * @prop {GlobalIntentResolved[]} routes
+ */
+
+/**
+ * @typedef {object} RouteOptions
+ * @prop {RouteCondition} [condition]
  */
 
 /**
@@ -110,7 +123,7 @@ class LLMRouter {
         this._route = routeResolver;
         this._global = global;
 
-        /** @typedef {GlobalIntentsMap} */
+        /** @type {GlobalIntentsMap} */
         this.globalIntents = new Map();
 
         if (global) {
@@ -226,11 +239,13 @@ class LLMRouter {
      *
      * @param {string} path
      * @param {string} classification
+     * @param {RouteOptions} [options]
      * @returns {MatchingResolver}
      */
-    route (path, classification) {
+    route (path, classification, options = {}) {
         return GlobalIntents.resolver(path, {
             classification,
+            ...options,
             router: this._route ? this : null,
             local: !this._global
         });
@@ -240,11 +255,13 @@ class LLMRouter {
      *
      * @param {string} path
      * @param {string} classification
+     * @param {RouteOptions} [options]
      * @returns {MatchingResolver}
      */
-    static route (path, classification) {
+    static route (path, classification, options = {}) {
         return GlobalIntents.resolver(path, {
-            classification
+            classification,
+            ...options
         });
     }
 
@@ -265,13 +282,20 @@ class LLMRouter {
         const byAction = new Map();
         let router = null;
         let keepUserInInteractionsWithBounceAllowed;
+        const routableLlm = resolvedLlm.filter((gi) => gi.classification);
 
-        const actionList = resolvedLlm.map((gi) => {
+        const actionList = routableLlm.map((gi) => {
             const { action, classification } = gi;
             byAction.set(LLMRouter._normByAction(gi.action), gi);
 
+            return { action, classification };
+        });
+
+        resolvedLlm.forEach((gi) => {
+
             if (typeof gi.keepUserInInteractionsWithBounceAllowed === 'boolean') {
-                keepUserInInteractionsWithBounceAllowed = true;
+                // eslint-disable-next-line max-len
+                keepUserInInteractionsWithBounceAllowed = gi.keepUserInInteractionsWithBounceAllowed;
             }
 
             if (router && router !== gi.router) {
@@ -279,8 +303,6 @@ class LLMRouter {
             } else {
                 router = gi.router;
             }
-
-            return { action, classification };
         });
 
         const actionListString = actionList
@@ -294,7 +316,8 @@ class LLMRouter {
             actionListString,
             actionList,
             byAction,
-            router
+            router,
+            routes: resolvedLlm
         };
     }
 
@@ -310,6 +333,7 @@ class LLMRouter {
         const globals = [];
         /** @type {ILLMRouter} */
         let router = null;
+        let keepUserInInteractionsWithBounceAllowed;
 
         for (const gi of globalIntents.values()) {
             if (!gi.classification
@@ -330,9 +354,24 @@ class LLMRouter {
                     throw new Error(`Detected more than one global router on '${gi.localPath}'. Only single global router allowed.`);
                 }
                 router = gi.router;
+
+                if (typeof gi.keepUserInInteractionsWithBounceAllowed === 'boolean') {
+                    // eslint-disable-next-line max-len
+                    keepUserInInteractionsWithBounceAllowed = gi.keepUserInInteractionsWithBounceAllowed;
+                }
             }
         }
 
+        const preparedGlobals = globals.length
+            ? LLMRouter._prepareRoutingInput(globals)
+            : {
+                actionListString: '',
+                actionList: [],
+                byAction: new Map(),
+                router: null,
+                routes: []
+            };
+
         return {
             router,
             locals: new Map(
@@ -342,7 +381,12 @@ class LLMRouter {
                         LLMRouter._prepareRoutingInput(locs)
                     ])
             ),
-            globals: LLMRouter._prepareRoutingInput(globals)
+            globals: {
+                ...preparedGlobals,
+                ...(typeof keepUserInInteractionsWithBounceAllowed === 'boolean'
+                    ? { keepUserInInteractionsWithBounceAllowed }
+                    : {})
+            }
         };
     }
 

package/src/Request.js

@@ -113,6 +113,7 @@ function makeTimestamp () {
  * @prop {'file'|'audio'|'video'|'image'|'location'} type
  * @prop {object} payload
  * @prop {string} payload.url
+ * @prop {string} [payload.name]
  */
 
 /**

package/src/prompt.js

@@ -11,7 +11,7 @@ const stateData = require('./utils/stateData');
 
 /**
  * @callback Renderer
- * @param {object|Request} req
+ * @param {Request} req
  * @param {Responder} [res]
  * @returns {Promise<string>}
  */

package/src/utils/compileWithState.js

@@ -21,6 +21,7 @@ const stateData = require('./stateData');
  * @param {Request} req
  * @param {Responder} res
  * @param {string} template
+ * @param {object} forcedData
  * @returns {string}
  * @example
  *
@@ -34,7 +35,7 @@ const stateData = require('./stateData');
  *     };
  * }
  */
-function compileWithState (req, res, template) {
+function compileWithState (req, res, template, forcedData = null) {
     if (!template) {
         return '';
     }
@@ -44,7 +45,7 @@ function compileWithState (req, res, template) {
     if (!template.includes('{{')) {
         return template;
     }
-    const data = stateData(req, res);
+    const data = forcedData || stateData(req, res);
     return handlebars.compile(template)(data);
 }