wingbot 3.76.18 → 3.77.0-alpha.1

package/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npx mocha:*)",
+      "Bash(npx tsc *)",
+      "Bash(npm test *)",
+      "Bash(node -e \"const p = require\\('./bot/plugins/BTMLLM'\\); console.log\\('factory type:', typeof p\\); console.log\\('factory name:', p.name\\);\")",
+      "Bash(grep -n \"prompt\\\\`\\\\|tagged\\\\|render\\\\|compile\\\\|hbs\" /Users/ondrejveres/Wingbot/wingbot-llm/src/prompt.js)"
+    ]
+  }
+}

package/index.js

@@ -70,6 +70,7 @@ const LLM = require('./src/LLM');
 const LLMSession = require('./src/LLMSession');
 const LLMTool = require('./src/LLMTool');
 const LLMType = require('./src/LLMType');
+const LLMToolRunner = require('./src/LLMToolRunner');
 const LLMRouter = require('./src/LLMRouter');
 const prompt = require('./src/prompt');
 
@@ -167,6 +168,7 @@ module.exports = {
     LLMSession,
     LLMTool,
     LLMType,
+    LLMToolRunner,
 
     LLMRouter,
     prompt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.76.18",
+  "version": "3.77.0-alpha.1",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "type": "commonjs",
@@ -75,7 +75,7 @@
   },
   "optionalDependencies": {
     "axios": "^1.6.4",
-    "handlebars": "^4.0.0"
+    "handlebars": "4.7.10"
   },
   "allowScripts": {
     "fsevents@2.3.2": true,

package/src/BuildRouter.js

@@ -157,12 +157,7 @@ const DUMMY_ROUTE = { id: 0, path: null, resolvers: [] };
  * @returns {string}
 */
 
-/**
- * @typedef {object} ILogger
- * @prop {Function} log
- * @prop {Function} warn
- * @prop {Function} error
- */
+/** @typedef {import('./log/types').LevelLogger} ILogger */
 
 /**
  * @template {BaseConfiguration} [C=object]
@@ -206,11 +201,7 @@ const DUMMY_ROUTE = { id: 0, path: null, resolvers: [] };
  * @prop {string|number} [resolverId] - only for text messages with random characters
  */
 
-/**
- * @typedef {object} Logger
- * @prop {Function} log
- * @prop {Function} error
- */
+/** @typedef {import('./log/types').LevelLogger} Logger */
 
 /**
  * @typedef {object} RunningReq
@@ -400,6 +391,30 @@ class BuildRouter extends Router {
         return this._botLoaded;
     }
 
+    /**
+     * What an expired request was about, without the whole request and
+     * responder (they hold the state and the transcript).
+     *
+     * @param {any[]} args - the reduce() arguments: (req, res, ...)
+     * @param {number} timeoutMs
+     * @returns {object}
+     */
+    static _expireInfo (args, timeoutMs) {
+        const [req] = Array.isArray(args) ? args : [];
+        let action = null;
+        try {
+            action = req && typeof req.action === 'function' ? req.action() : null;
+        } catch (e) {
+            // the action is only a hint
+        }
+        return {
+            senderId: (req && req.senderId) || null,
+            pageId: (req && req.pageId) || null,
+            action,
+            timeoutMs
+        };
+    }
+
     async reduce (...args) {
         await this.preload();
 
@@ -411,7 +426,7 @@ class BuildRouter extends Router {
             const timeoutPromise = new Promise((resolve) => {
                 timeout = setTimeout(() => {
                     timeout = null;
-                    this._logger.error('BuildRouter EXPIRE', { args });
+                    this._logger.error('BuildRouter EXPIRE', BuildRouter._expireInfo(args, this.runningReqTimeout));
                     this._runningReqs = this._runningReqs
                         .filter((rr) => rr !== runningRequest);
                     resolve();
@@ -527,7 +542,10 @@ class BuildRouter extends Router {
                 this._runningReqs
                     .filter((req) => {
                         if (req.started < threshold) {
-                            this._logger.error('BuildRouter EXPIRE filter', req);
+                            this._logger.error('BuildRouter EXPIRE filter', {
+                                ...BuildRouter._expireInfo(req.args, this.runningReqTimeout),
+                                startedAt: new Date(req.started).toISOString()
+                            });
                             return false;
                         }
                         return true;

package/src/CallbackAuditLog.js

@@ -35,11 +35,7 @@ const TYPE_INFO = 'Info';
  * @prop {string} [ro] - referrer || origin
  */
 
-/**
- * @typedef {object} Logger
- * @prop {Function} log
- * @prop {Function} error
- */
+/** @typedef {import('./log/types').LevelLogger} Logger */
 
 /**
  * @typedef {object} AuditLogEntry

package/src/ChatGpt.js

@@ -4,7 +4,6 @@
 'use strict';
 
 const nodeFetch = require('node-fetch').default;
-const util = require('util');
 const { PHONE_REGEX, EMAIL_REGEX } = require('./systemEntities/regexps');
 const LLM = require('./LLM');
 
@@ -101,11 +100,7 @@ const LLM = require('./LLM');
  * @prop {ChatGPTUsage} usage
  */
 
-/**
- * @typedef {object} Logger
- * @prop {Function} log
- * @prop {Function} error
- */
+/** @typedef {import('./log/types').LevelLogger} Logger */
 
 /**
  * @typedef {object} GptToolCall
@@ -178,6 +173,9 @@ const LLM = require('./LLM');
 /**
  * @class ChatGpt
  */
+// how much of the input and the output the info row of an LLM call keeps
+const SUMMARY_TEXT_LENGTH = 2000;
+
 class ChatGpt {
 
     /**
@@ -242,15 +240,41 @@ class ChatGpt {
         return this._options.model;
     }
 
-    _log (msg, ...args) {
-        if (this._logger === console) {
-
-            this._logger.log(msg, ...args.map((arg) => util.inspect(arg, {
-                showHidden: false, depth: null, colors: true
-            })));
-        } else {
-            this._logger.log(msg, ...args);
-        }
+    /**
+     * The info row of one LLM call: the new input (the last message, not the
+     * whole transcript), the output and the usage. The whole request and
+     * response are in the debug rows.
+     *
+     * @param {object} body - the request body
+     * @param {ChatGPTChoice} choice
+     * @param {LLMUsage} usage
+     * @param {number} durationMs
+     * @returns {object}
+     */
+    static _summary (body, choice, usage, durationMs) {
+        const { messages = [], tools = [] } = body;
+        const last = messages[messages.length - 1] || {};
+        const { message = {}, finish_reason: finishReason } = choice || {};
+        const cut = (text) => (typeof text === 'string' && text.length > SUMMARY_TEXT_LENGTH
+            ? `${text.slice(0, SUMMARY_TEXT_LENGTH)}… (${text.length - SUMMARY_TEXT_LENGTH} more chars)`
+            : text);
+        return {
+            ...usage,
+            durationMs,
+            finishReason,
+            messageCount: messages.length,
+            toolCount: tools.length,
+            input: { role: last.role, content: cut(last.content) },
+            output: cut(message.content),
+            ...(message.tool_calls && message.tool_calls.length
+                ? {
+                    toolCalls: message.tool_calls.map((tc) => ({
+                        name: tc.function && tc.function.name,
+                        args: cut(tc.function && tc.function.arguments)
+                    }))
+                }
+                : {})
+        };
     }
 
     /**
@@ -457,7 +481,8 @@ class ChatGpt {
 
             const apiUrl = `${this._openAiEndpoint}/chat/completions${this._apiKey ? `?api-version=${encodeURIComponent(this._apiVersion)}` : ''}`;
 
-            this._log('#GPT request', body);
+            // the whole prompt: verbose only (or replayed with an error)
+            this._logger.debug('#GPT request', body);
 
             const startTime = Date.now();
             const response = await this._fetch(apiUrl, {
@@ -508,11 +533,14 @@ class ChatGpt {
 
             const durationMs = Date.now() - startTime;
 
-            this._log('#GPT response', { choice, responseData, durationMs });
+            this._logger.debug('#GPT response body', { responseData, durationMs });
+            this._logger.info('#GPT response', ChatGpt._summary(body, choice, llmUsage, durationMs));
 
             return { choice, usage: llmUsage };
         } catch (e) {
-            this._logger.log('#GPT failed', {
+            // the caller logs the error once (LLMSession: the fallback message);
+            // the detail goes with it (replayed with the error)
+            this._logger.debug('#GPT failed', {
                 message: e.message, body, responseText, responseData, status, statusText
             });
             throw e;

package/src/ConversationTester.js

@@ -95,11 +95,7 @@ const DEFAULT_TEXT_THRESHOLD = 0.8;
  * @prop {number} stepCount
  */
 
-/**
- * @typedef {object} Logger
- * @prop {Function} log
- * @prop {Function} error
- */
+/** @typedef {import('./log/types').LevelLogger} Logger */
 
 /**
  * Automated Conversation tests runner

package/src/LLM.js

@@ -60,6 +60,7 @@ const LLMSession = require('./LLMSession');
  * @typedef {object} PrepocessedRuleData
  * @prop {Function} condition
  * @prop {PreprocessorOutput} rule
+ * @prop {string[]} [aiTags] - original rule definition (from the designer), for logs
  */
 
 /**
@@ -75,12 +76,24 @@ const LLMSession = require('./LLMSession');
  * @typedef {RuleScore & PreprocessedRule} RuleWithScore
  */
 
+/**
+ * @typedef {object} EvaluatedRule
+ * @prop {string|number} [id]
+ * @prop {EvaluationRuleAction} [action]
+ * @prop {string[]} [aiTags]
+ * @prop {boolean} conditionPassed - false, when the rule was skipped by its condition
+ * @prop {number} score - 0, when the rule did not match at all
+ * @prop {boolean} matched - score reached the threshold
+ */
+
 /**
  * @typedef {object} EvaluationResult
  * @prop {string} action
  * @prop {boolean} discard
  * @prop {RuleWithScore[]} results
  * @prop {object} setState
+ * @prop {number} [threshold] - minimal score of a matching rule
+ * @prop {EvaluatedRule[]} [evaluated] - every rule and the decision made about it
  */
 
 /**
@@ -190,11 +203,7 @@ const LLMSession = require('./LLMSession');
  * @prop {LogPrompt} logPrompt
  */
 
-/**
- * @typedef {object} Logger
- * @prop {Function} log
- * @prop {Function} error
- */
+/** @typedef {import('./log/types').LevelLogger} Logger */
 
 /**
  * @typedef {object} VectorSearchDocument
@@ -527,6 +536,8 @@ class LLM {
 
             return {
                 ...rest,
+                // kept, so logs can show the rule as it was defined in the designer
+                aiTags,
                 condition,
                 rule
             };
@@ -559,14 +570,27 @@ class LLM {
         const setState = {};
 
         const sAct = Object.values(LLM.EVALUATION_ACTIONS);
+        const { threshold } = this._ai;
+
+        /** @type {EvaluatedRule[]} */
+        const evaluated = [];
 
         const results = rules
-            .filter((rule) => rule.condition(req, res))
+            .filter((rule) => {
+                const conditionPassed = !!rule.condition(req, res);
+                if (!conditionPassed) {
+                    evaluated.push(LLM._describeRule(rule, false, 0, threshold));
+                }
+                return conditionPassed;
+            })
             .map((rule) => {
                 const matched = this._ai.matcher
                     .matchText(text, rule.rule, nlpResult, state);
 
-                if (!matched || matched.score < this._ai.threshold) {
+                const score = matched ? matched.score : 0;
+                evaluated.push(LLM._describeRule(rule, true, score, threshold));
+
+                if (!matched || matched.score < threshold) {
                     return null;
                 }
 
@@ -594,10 +618,51 @@ class LLM {
             setState,
             results,
             discard,
-            action: discard ? null : topRankedAction
+            action: discard ? null : topRankedAction,
+            threshold,
+            evaluated
+        };
+    }
+
+    /**
+     * Rule as a plain object for logs (RegExp objects serialize as {})
+     *
+     * @param {PreprocessedRule} rule
+     * @param {boolean} conditionPassed
+     * @param {number} score
+     * @param {number} threshold
+     * @returns {EvaluatedRule}
+     */
+    static _describeRule (rule, conditionPassed, score, threshold) {
+        // @ts-ignore
+        const { id, action = null, aiTags } = rule;
+        return {
+            id,
+            action,
+            aiTags: aiTags || LLM._ruleTags(rule.rule),
+            conditionPassed,
+            score,
+            matched: conditionPassed && score >= threshold
         };
     }
 
+    /**
+     * Fallback for rules added without their definition
+     *
+     * @param {PreprocessorOutput} rule
+     * @returns {string[]}
+     */
+    static _ruleTags (rule) {
+        if (!rule) return [];
+        /** @type {any} */
+        const r = rule;
+        return [
+            ...(r.regexps || []).map((x) => `regexp:${x.r instanceof RegExp ? x.r.source : x.r}`),
+            ...(r.intents || []).map((i) => `intent:${i}`),
+            ...(r.entities || []).map((e) => `@${e.entity}${e.optional ? '?' : ''}`)
+        ];
+    }
+
 }
 
 module.exports = LLM;

package/src/LLMDispatcher.js

@@ -39,11 +39,7 @@ const BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{
  * @prop {RouterResolver} resolve
  */
 
-/**
- * @typedef {object} Logger
- * @prop {Function} log
- * @prop {Function} error
- */
+/** @typedef {import('./log/types').LevelLogger} Logger */
 
 /**
  * @typedef {object} DispatcherOptions

package/src/LLMSession.js

@@ -101,6 +101,7 @@ const stateData = require('./utils/stateData');
 /**
  * @callback ToolFnCallback
  * @param {{[key: string]: any}} input
+ * @param {LLMSession} [session] - call `session.stop()` to end the generation after the tool
  * @returns {string|Promise<string>}
  */
 
@@ -256,6 +257,8 @@ class LLMSession {
 
         /** @type {PossiblyAsyncContent|null} */
         this._fallbackMessage = null;
+
+        this._stopped = false;
     }
 
     /**
@@ -374,6 +377,15 @@ class LLMSession {
             .then(onFulfilled, onRejected);
     }
 
+    /**
+     * the preset (or the provider options), the session generates with by default
+     *
+     * @returns {string|object}
+     */
+    get preset () {
+        return this._preset;
+    }
+
     /**
      * @returns {ToolFunction[]}
      */
@@ -429,7 +441,7 @@ class LLMSession {
         } else if (errors.length) {
             // @ts-ignore
             const errs = errors.map((e) => e.error);
-            this._llm.log.log('LLMSession failures', errs);
+            this._llm.log.debug('LLMSession failures', { errors: errs.map((e) => e.message) });
             throw new Error(errs.map((e) => e.message).join(', '));
         }
     }
@@ -903,6 +915,28 @@ class LLMSession {
         return this;
     }
 
+    /**
+     * Ends the generation right after the current round of tool calls - the model
+     * is not asked again and nothing generated in this session is sent.
+     *
+     * Meant to be called from within a tool, which takes over the conversation
+     * (e.g. makes a postback to an interaction). It's applied immediately
+     * (not queued), because the tool already runs inside a queued job.
+     *
+     * @returns {this}
+     */
+    stop () {
+        this._stopped = true;
+        return this;
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    isStoppedSync () {
+        return this._stopped;
+    }
+
     /**
      * @returns {Promise<string>}
      */
@@ -1024,6 +1058,16 @@ class LLMSession {
                     },
                     ...results.filter((r) => !!r)
                 );
+            }
+
+            if (this._stopped) {
+                // a tool took over the conversation - drop any text generated
+                // alongside the tool calls and don't ask the model again
+                result = { role: ROLE_ASSISTANT, content: null };
+                break;
+            }
+
+            if (toolCalls.length) {
                 result = await this._llm.generate(this, providerOptions, logOptions);
             } else {
                 // everything failed - force a final text answer without tools
@@ -1093,7 +1137,7 @@ class LLMSession {
         let args;
         try {
             args = JSON.parse(toolCall.args);
-            const fnResult = await Promise.resolve(tool.fn(args));
+            const fnResult = await Promise.resolve(tool.fn(args, this));
 
             /**
              * {
@@ -1193,6 +1237,9 @@ class LLMSession {
      */
     send (quickReplies = undefined) {
         this._job(() => {
+            if (this._stopped) {
+                return;
+            }
             const messages = this.messagesToSendSync();
             this._onSend(messages, quickReplies);
         }, true);