wingbot 3.76.4-alpha.8 → 3.76.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.76.4-alpha.8",
+  "version": "3.76.4",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "type": "commonjs",

package/src/Ai.js

@@ -9,8 +9,7 @@ const { vars } = require('./utils/stateVariables');
 const { deepEqual } = require('./utils/deepMapTools');
 const systemEntities = require('./systemEntities');
 const CustomEntityDetectionModel = require('./wingbot/CustomEntityDetectionModel');
-
-let uq = 1;
+const GlobalIntents = require('./GlobalIntents');
 
 /** @typedef {import('./AiMatching').Compare} Compare */
 
@@ -444,21 +443,16 @@ class Ai {
         const rules = this.matcher.preprocessRule(intents);
         const matcher = this._createIntentMatcher(rules, usedEntities);
         const entitiesSetState = Ai.ai.matcher.getSetStateForEntityRules(rules);
-        const id = uq++;
 
-        const resolver = {
-            path,
-            globalIntents: new Map([[id, {
-                id,
-                matcher,
-                usedEntities,
-                entitiesSetState,
-                local: false,
-                action: '/*',
-                title,
-                meta
-            }]])
-        };
+        const resolver = GlobalIntents.resolver(path, {
+            matcher,
+            usedEntities,
+            entitiesSetState,
+            local: false,
+            action: '/*',
+            title,
+            meta
+        });
 
         return resolver;
     }
@@ -488,12 +482,10 @@ class Ai {
         const rules = this.matcher.preprocessRule(intents);
         const matcher = this._createIntentMatcher(rules, usedEntities);
         const entitiesSetState = Ai.ai.matcher.getSetStateForEntityRules(rules);
-        const id = uq++;
 
-        const resolver = {
+        const resolver = GlobalIntents.resolver(
             path,
-            globalIntents: new Map([[id, {
-                id,
+            {
                 matcher,
                 usedEntities,
                 entitiesSetState,
@@ -501,8 +493,8 @@ class Ai {
                 action: '/*',
                 title,
                 meta: {}
-            }]])
-        };
+            }
+        );
 
         return resolver;
     }

package/src/BuildRouter.js

@@ -865,13 +865,20 @@ class BuildRouter extends Router {
     _createBlockLlmRouter (block) {
         const { llmRouting } = block;
 
-        if (!llmRouting || !llmRouting.prompt || !llmRouting.prompt.trim()) {
+        if (!llmRouting) {
             return null;
         }
 
-        const routeResolver = LLMRouter.defaultRoute(
-            async (resolvedData) => compileWithState(null, null, llmRouting.prompt, resolvedData)
-        );
+        const routeResolver = llmRouting.prompt && llmRouting.prompt.trim()
+            ? LLMRouter.defaultRoute(
+                async (resolvedData) => compileWithState(
+                    null,
+                    null,
+                    llmRouting.prompt,
+                    resolvedData
+                )
+            )
+            : null;
         const options = llmRouting.bounce === 'keepAllow'
             ? { keepUserInInteractionsWithBounceAllowed: true }
             : {};

package/src/ChatGpt.js

@@ -47,6 +47,7 @@ const LLM = require('./LLM');
  * @prop {ChatGPTModel} [model]
  * @prop {'none'|'low'|'medium'|'high'} [reasoningEffort]
  * @prop {number} [presencePenalty=0.0]
+ * @prop {number} [frequencyPenalty=0.0]
  * @prop {number} [requestTokens]
  * @prop {number} [tokensLimit]
  * @prop {number} [temperature=1.0]
@@ -209,6 +210,7 @@ class ChatGpt {
             requestTokens: null,
             tokensLimit: null,
             presencePenalty: 0.0, // -2.0-2.0
+            frequencyPenalty: 0.0, // -2.0-2.0
             temperature: 1.0,
             model: 'gpt-4o-mini',
             transcriptLength: -5,
@@ -305,6 +307,7 @@ class ChatGpt {
             tokensLimit,
             model,
             presencePenalty,
+            frequencyPenalty,
             temperature,
             reasoningEffort,
             functions = [],
@@ -403,7 +406,7 @@ class ChatGpt {
 
             body = {
                 model,
-                frequency_penalty: 0,
+                frequency_penalty: frequencyPenalty ?? 0,
                 presence_penalty: presencePenalty,
                 ...(requestTokens ? {
                     max_completion_tokens: requestTokens

package/src/LLM.js

@@ -107,6 +107,9 @@ const LLMSession = require('./LLMSession');
  * @prop {'low'|'medium'|'high'|string} [verbosity]
  * @prop {'text'|SimpleJsonSchema} [responseFormat]
  * @prop {number} [temperature]
+ * @prop {number} [presencePenalty]
+ * @prop {number} [frequencyPenalty]
+ * @prop {number} [maxToolCallRounds]
  */
 
 /**
@@ -157,10 +160,12 @@ const LLMSession = require('./LLMSession');
 /**
  * @typedef {object} PromptInfo
  * @prop {LLMMessage[]} prompt
- * @prop {LLMMessage} result
+ * @prop {LLMMessage|null} result
  * @prop {VectorSearchResult} [vectorSearchResult]
  * @prop {ToolFunction[]} [tools]
  * @prop {number} [durationMs]
+ * @prop {LLMCallOptions} [options]
+ * @prop {string} [error]
  */
 
 /**
@@ -427,24 +432,47 @@ class LLM {
         const opts = this.llmOptions(preset);
         const prompt = await session.toArray(true);
         const startTime = Date.now();
-        const result = await this._provider.requestChat(prompt, opts, session.tools);
+        let result = null;
+        let error = null;
+        try {
+            result = await this._provider.requestChat(prompt, opts, session.tools);
+        } catch (e) {
+            error = e;
+        }
         const durationMs = Date.now() - startTime;
-        this.logPrompt(prompt, result, logOptions.vectorSearchResult, session.tools, durationMs);
+        this.logPrompt(
+            prompt,
+            result,
+            logOptions.vectorSearchResult,
+            session.tools,
+            durationMs,
+            opts,
+            error
+        );
+        if (error) throw error;
         return result;
     }
 
     /**
      *
      * @param {LLMMessage[]} prompt
-     * @param {LLMMessage} result
+     * @param {LLMMessage|null} result
      * @param {VectorSearchResult} [vectorSearchResult]
      * @param {ToolFunction[]} [tools]
      * @param {number} [durationMs]
+     * @param {LLMCallOptions} [options]
+     * @param {Error} [error]
      */
-    logPrompt (prompt, result, vectorSearchResult, tools, durationMs) {
+    logPrompt (prompt, result, vectorSearchResult, tools, durationMs, options, error) {
         this._lastResult = result;
         this._configuration.logger.logPrompt({
-            prompt, result, vectorSearchResult, tools, durationMs
+            prompt,
+            result,
+            vectorSearchResult,
+            tools,
+            durationMs,
+            ...(options != null && { options }),
+            ...(error != null && { error: error?.message || String(error) })
         });
     }
 

package/src/LLMSession.js

@@ -175,6 +175,30 @@ const stateData = require('./utils/stateData');
 // before we force a tool-less final answer (guards against tool-call loops)
 const MAX_TOOL_CALL_ROUNDS = 5;
 
+// LLMs occasionally emit the same answer twice in a row within a single message
+// shorter texts are left alone - repeating them can be intentional
+const MIN_REPEATED_LENGTH = 24;
+const MAX_DEDUPLICATED_LENGTH = 8000;
+
+const REPEATED_TEXT_RE = new RegExp(`^([\\s\\S]{${MIN_REPEATED_LENGTH},}?)(?:\\s*\\1)+$`);
+
+/**
+ * Collapses text consisting purely of a repeated block ("hello. hello.") into a single occurrence
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function deduplicateRepeatedText (text) {
+    const trimmed = text.trim();
+
+    if (trimmed.length < MIN_REPEATED_LENGTH * 2 || trimmed.length > MAX_DEDUPLICATED_LENGTH) {
+        return text;
+    }
+    const match = trimmed.match(REPEATED_TEXT_RE);
+
+    return match ? match[1] : text;
+}
+
 /**
  * @class LLMSession
  * @implements {PromiseLike<LLMMessage<any>>}
@@ -973,12 +997,13 @@ class LLMSession {
      * @returns {Promise<LLMMessage<any>>}
      */
     async _generate (providerOptions = this._preset, logOptions = {}) {
+        const { maxToolCallRounds = MAX_TOOL_CALL_ROUNDS } = this._llm.llmOptions(providerOptions);
         let result = await this._llm.generate(this, providerOptions, logOptions);
 
         // the model may chain several rounds of tool calls before it produces
         // a final text answer - keep resolving them until it stops (bounded)
         let rounds = 0;
-        while (result.toolCalls?.length && rounds < MAX_TOOL_CALL_ROUNDS) {
+        while (result.toolCalls?.length && rounds < maxToolCallRounds) {
             rounds += 1;
             const toolCalls = [];
             const results = await Promise.all(
@@ -1017,7 +1042,7 @@ class LLMSession {
         // a tool-call message (content === null) to the send pipeline
         if (result.toolCalls?.length) {
             this._llm.log.error(
-                `LLMSession: reached MAX_TOOL_CALL_ROUNDS (${MAX_TOOL_CALL_ROUNDS}), `
+                `LLMSession: reached maxToolCallRounds (${maxToolCallRounds}), `
                 + 'dropping pending tool calls and forcing a tool-less final answer',
                 { toolCalls: result.toolCalls }
             );
@@ -1185,12 +1210,13 @@ class LLMSession {
         if (typeof result.content !== 'string') {
             return [];
         }
-        let filtered = result.content
+        let filtered = deduplicateRepeatedText(result.content.trim())
             .replace(/\n\n\n+/g, '\n\n')
             .split(/\n\n+(?!\s*-)/g)
-            .map((t) => t.replace(/\s*\n\s+/g, '\n')
-                .trim())
-            .filter((t) => !!t);
+            .map((t) => deduplicateRepeatedText(t.replace(/\s*\n\s+/g, '\n')
+                .trim()))
+            .filter((t, i, all) => !!t
+                && !(t.length >= MIN_REPEATED_LENGTH && t === all[i - 1]));
 
         if (result.finishReason === 'length' && filtered.length <= 0) {
             filtered = filtered.slice(0, filtered.length - 1);

package/src/resolvers/languageText.js

@@ -0,0 +1,85 @@
+/*
+ * @author David Menger
+ */
+'use strict';
+
+/**
+ * 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 {Purpose | Purpose[]} [p] - purposes
+ */
+
+/**
+ * @typedef {Translation[] | Translation | string[] | string} Translations
+ */
+
+/**
+ * @param {string | string[] | Translation | Translation[]} translations
+ * @returns {translations is Translation[]}
+ */
+function isArrayOfObjects (translations) {
+    return Array.isArray(translations)
+        && typeof translations[0] === 'object'
+        && translations[0] !== null;
+}
+
+function isTextObjectEmpty (text) {
+    if (!text || !text.t) {
+        return true;
+    }
+    if (Array.isArray(text.t)) {
+        return !text.t.some((t) => !!t);
+    }
+    return false;
+}
+
+/**
+ * @param {Translations} translations
+ * @param {string} [lang]
+ * @param {boolean} [disableDefaulting] - it will try to find translation for other language
+ * @returns {null|string|string[]}
+ */
+function getLanguageText (translations, lang = null, disableDefaulting = false) {
+    let foundText;
+
+    if (isArrayOfObjects(translations)) {
+        if (lang) {
+            // @ts-ignore
+            foundText = translations.find((t) => t.l === lang);
+        } else if (disableDefaulting) {
+            // @ts-ignore
+            [foundText] = translations;
+        }
+        if (isTextObjectEmpty(foundText) && !disableDefaulting) {
+            // @ts-ignore
+            foundText = translations.find((t) => !isTextObjectEmpty(t));
+        }
+        foundText = foundText ? foundText.t : null;
+    } else {
+        foundText = translations;
+    }
+    if (Array.isArray(foundText)) {
+        foundText = foundText.filter((f) => !!f);
+
+        if (foundText.length === 0) {
+            return '';
+        }
+    }
+    return foundText || '';
+}
+
+module.exports = {
+    getLanguageText,
+    isTextObjectEmpty,
+    isArrayOfObjects
+};

package/src/resolvers/utils.js

@@ -6,6 +6,7 @@
 const hbs = require('./hbs');
 const stateData = require('../utils/stateData');
 const getCondition = require('../utils/getCondition');
+const { isTextObjectEmpty, getLanguageText } = require('./languageText');
 
 const ASPECT_SQUARE = 'square';
 const ASPECT_HORISONTAL = 'horisontal';
@@ -20,10 +21,6 @@ const WEBVIEW_FULL = 'full';
 const WEBVIEW_TALL = 'tall';
 const WEBVIEW_COMPACT = 'compact';
 
-/**
- * @typedef {Translation[] | Translation | string[] | string} Translations
- */
-
 /**
  * @typedef {object} TextObject
  * @prop {string} t - text
@@ -31,76 +28,10 @@ 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 {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'
-        && translations[0] !== null;
-}
-
-function isTextObjectEmpty (text) {
-    if (!text || !text.t) {
-        return true;
-    }
-    if (Array.isArray(text.t)) {
-        return !text.t.some((t) => !!t);
-    }
-    return false;
-}
-
-/**
- * @param {Translations} translations
- * @param {string} [lang]
- * @param {boolean} [disableDefaulting] - it will try to find translation for other language
- * @returns {null|string|string[]}
- */
-function getLanguageText (translations, lang = null, disableDefaulting = false) {
-    let foundText;
-
-    if (isArrayOfObjects(translations)) {
-        if (lang) {
-            // @ts-ignore
-            foundText = translations.find((t) => t.l === lang);
-        } else if (disableDefaulting) {
-            // @ts-ignore
-            [foundText] = translations;
-        }
-        if (isTextObjectEmpty(foundText) && !disableDefaulting) {
-            // @ts-ignore
-            foundText = translations.find((t) => !isTextObjectEmpty(t));
-        }
-        foundText = foundText ? foundText.t : null;
-    } else {
-        foundText = translations;
-    }
-    if (Array.isArray(foundText)) {
-        foundText = foundText.filter((f) => !!f);
+/** @typedef {import('./languageText').Translation} Translation */
+/** @typedef {import('./languageText').Translations} Translations */
+/** @typedef {import('./languageText').Purpose} Purpose */
 
-        if (foundText.length === 0) {
-            return '';
-        }
-    }
-    return foundText || '';
-}
 /**
  *
  * @param {Translations} translations

package/src/testTools/PromptAssert.js

@@ -88,7 +88,8 @@ class PromptAssert {
      */
     _flatResults () {
         return this._prompts
-            .map((prompt) => prompt.result);
+            .map((prompt) => prompt.result)
+            .filter(Boolean);
     }
 
     /**
@@ -190,7 +191,7 @@ class PromptAssert {
                 return [
                     `${i + 1}) ${PromptAssert.promptStats(p.prompt)}`,
                     `${prompt.join('\n   ')}`,
-                    `# ${PromptAssert._content(p.result)}`
+                    `# ${p.result ? PromptAssert._content(p.result) : `[ERROR] ${p.error || 'unknown'}`}`
                 ].join('\n   ');
             });
         }

package/src/transcript/extractText.js

@@ -16,13 +16,19 @@ function extractText (payload) {
         return payload.message.text;
     }
 
-    // button message
-    if (payload.message && payload.message.attachment
-        && payload.message.attachment.type === 'template'
-        && payload.message.attachment.payload
-        && payload.message.attachment.payload.text) {
-
-        return payload.message.attachment.payload.text;
+    // button message — the orchestrator normalizes a singular `attachment` into
+    // a plural `attachments` array before persisting, so accept both shapes;
+    // otherwise template messages (e.g. button templates) logged via the
+    // orchestrator drop out of the transcript entirely.
+    const attachment = payload.message
+        && (payload.message.attachment
+            || (Array.isArray(payload.message.attachments) && payload.message.attachments[0]));
+    if (attachment
+        && attachment.type === 'template'
+        && attachment.payload
+        && attachment.payload.text) {
+
+        return attachment.payload.text;
     }
 
     if (!payload.postback) {

package/src/utils/compileWithState.js

@@ -10,17 +10,41 @@ try {
 } catch (er) {
     handlebars = { compile: (text) => () => text };
 }
+const { getLanguageText } = require('../resolvers/languageText');
 const stateData = require('./stateData');
 
+/** @typedef {import('../resolvers/languageText').Translation} Translation */
+
 /** @typedef {import('../Request')} Request */
 /** @typedef {import('../Responder')} Responder */
 
+function compileAndRenderOut (template, req, res, data) {
+    if (!template) {
+        return '';
+    }
+    if (typeof template !== 'string') {
+        return `${template}`;
+    }
+    if (!template.includes('{{')) {
+        return template;
+    }
+
+    const useData = data || stateData(req, res);
+    let result = template;
+    let hasHandlebars = true;
+    for (let i = 0; i < 10 && hasHandlebars; i++) {
+        result = handlebars.compile(result)(useData);
+        hasHandlebars = template.includes('{{');
+    }
+    return result;
+}
+
 /**
  * Utility, which helps to render handlebars syntax with all variables within conversations state
  *
  * @param {Request} req
  * @param {Responder} res
- * @param {string} template
+ * @param {string|Translation[]} template
  * @param {object} forcedData
  * @returns {string}
  * @example
@@ -39,15 +63,15 @@ function compileWithState (req, res, template, forcedData = null) {
     if (!template) {
         return '';
     }
-    if (typeof template !== 'string') {
-        return `${template}`;
-    }
-    const data = forcedData || stateData(req, res);
-    let result = template;
-    for (let i = 0; i < 10 && result.includes('{{'); i++) {
-        result = handlebars.compile(result)(data);
+    let tpl;
+    let data;
+    if (Array.isArray(template)) {
+        data = stateData(req, res);
+        tpl = getLanguageText(template, data.lang);
+    } else {
+        tpl = template;
     }
-    return result;
+    return compileAndRenderOut(tpl, req, res, forcedData || data);
 }
 
 module.exports = compileWithState;