wingbot 3.76.4-alpha.1 → 3.76.4-alpha.11

package/package.json

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

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

@@ -441,6 +441,7 @@ class ChatGpt {
 
             this._log('#GPT request', body);
 
+            const startTime = Date.now();
             const response = await this._fetch(apiUrl, {
                 method: 'POST',
                 headers: {
@@ -470,7 +471,9 @@ class ChatGpt {
 
             const [choice] = responseData.choices;
 
-            this._log('#GPT response', { choice, responseData });
+            const durationMs = Date.now() - startTime;
+
+            this._log('#GPT response', { choice, responseData, durationMs });
 
             return choice;
         } catch (e) {

package/src/LLM.js

@@ -112,6 +112,7 @@ const LLMSession = require('./LLMSession');
 /**
  * @typedef {object} LLMLogOptions
  * @prop {VectorSearchResult} [vectorSearchResult]
+ * @prop {ToolFunction[]} [tools]
  */
 
 /**
@@ -158,6 +159,7 @@ const LLMSession = require('./LLMSession');
  * @prop {LLMMessage[]} prompt
  * @prop {LLMMessage} result
  * @prop {VectorSearchResult} [vectorSearchResult]
+ * @prop {ToolFunction[]} [tools]
  */
 
 /**
@@ -424,7 +426,7 @@ class LLM {
         const opts = this.llmOptions(preset);
         const prompt = await session.toArray(true);
         const result = await this._provider.requestChat(prompt, opts, session.tools);
-        this.logPrompt(prompt, result, logOptions.vectorSearchResult);
+        this.logPrompt(prompt, result, logOptions.vectorSearchResult, session.tools);
         return result;
     }
 
@@ -433,11 +435,12 @@ class LLM {
      * @param {LLMMessage[]} prompt
      * @param {LLMMessage} result
      * @param {VectorSearchResult} [vectorSearchResult]
+     * @param {ToolFunction[]} [tools]
      */
-    logPrompt (prompt, result, vectorSearchResult) {
+    logPrompt (prompt, result, vectorSearchResult, tools) {
         this._lastResult = result;
         this._configuration.logger.logPrompt({
-            prompt, result, vectorSearchResult
+            prompt, result, vectorSearchResult, tools
         });
     }
 

package/src/LLMDispatcher.js

@@ -260,6 +260,7 @@ class LLMDispatcher {
                 ...routing,
                 actionList: [],
                 actionListString: '',
+                structuredOutput: LLMRouter.structuredOutput(),
                 byAction: new Map(),
                 router
             };

package/src/LLMRouter.js

@@ -66,7 +66,8 @@ const LLMType = require('./LLMType');
  */
 
 /**
- * @typedef {Pick<LLMRoutingCache, 'actionList'|'actionListString'|'byAction'>} LLMRoutingInput
+ * @typedef {Pick<LLMRoutingCache,
+ *   'actionList'|'actionListString'|'byAction'|'structuredOutput'>} LLMRoutingInput
  */
 
 /**
@@ -74,6 +75,7 @@ const LLMType = require('./LLMType');
  * @prop {boolean} [keepUserInInteractionsWithBounceAllowed]
  * @prop {string} actionListString
  * @prop {LLMAction[]} actionList
+ * @prop {object} structuredOutput - JSON schema for the routing response
  * @prop {ILLMRouter|null} router
  * @prop {Map<string, GlobalIntentResolved>} byAction
  * @prop {GlobalIntentResolved[]} routes
@@ -142,24 +144,31 @@ class LLMRouter {
     }
 
     /**
-     * @type {object}
+     * Sentinel action returned when the user did not change the conversation
+     * context (or when the model can't decide). Not present in `byAction`.
+     *
+     * @type {string}
      */
-    static _cachedStructuredOutput = null;
+    static NOT_CHANGED = '-not-changed-';
 
     /**
+     * Builds the JSON schema for the routing response. The `action` field is
+     * constrained to an enum of the routable actions plus the `-not-changed-`
+     * sentinel, so the model can only return a valid routing target.
+     *
+     * Called once per router config from `_prepareRoutingInput`; the result is
+     * stored on the routing cache, so it is not rebuilt per request.
      *
+     * @param {string[]} [actions] - routable action values (e.g. `/btm/dodavatel`)
      * @returns {object}
      */
-    static structuredOutput () {
-        if (LLMRouter._cachedStructuredOutput === null) {
-            LLMRouter._cachedStructuredOutput = LLMType
-                .object({
-                    action: LLMType.string()
-                        .description('recommended action')
-                }, 'conversation_routing_information')
-                .toJSON();
-        }
-        return LLMRouter._cachedStructuredOutput;
+    static structuredOutput (actions = []) {
+        return LLMType
+            .object({
+                action: LLMType.enum([LLMRouter.NOT_CHANGED, ...actions])
+                    .description('recommended action')
+            }, 'conversation_routing_information')
+            .toJSON();
     }
 
     /**
@@ -183,7 +192,7 @@ class LLMRouter {
 
             let res;
             try {
-                res = await session.generateStructured(LLMRouter.structuredOutput());
+                res = await session.generateStructured(routing.structuredOutput);
             } catch (e) {
                 // Fail closed: any error in routing classification is treated
                 // as "no context change" so the user's current flow continues.
@@ -315,6 +324,7 @@ class LLMRouter {
                 : {}),
             actionListString,
             actionList,
+            structuredOutput: LLMRouter.structuredOutput(actionList.map((a) => a.action)),
             byAction,
             router,
             routes: resolvedLlm
@@ -367,6 +377,7 @@ class LLMRouter {
             : {
                 actionListString: '',
                 actionList: [],
+                structuredOutput: LLMRouter.structuredOutput(),
                 byAction: new Map(),
                 router: null,
                 routes: []

package/src/LLMSession.js

@@ -170,6 +170,10 @@ const stateData = require('./utils/stateData');
  * @prop {LLMCallPreset} [preset]
  */
 
+// max number of consecutive tool-call rounds resolved within a single generate()
+// before we force a tool-less final answer (guards against tool-call loops)
+const MAX_TOOL_CALL_ROUNDS = 5;
+
 /**
  * @class LLMSession
  * @implements {PromiseLike<LLMMessage<any>>}
@@ -970,7 +974,11 @@ class LLMSession {
     async _generate (providerOptions = this._preset, logOptions = {}) {
         let result = await this._llm.generate(this, providerOptions, logOptions);
 
-        if (result.toolCalls?.length) {
+        // 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) {
+            rounds += 1;
             const toolCalls = [];
             const results = await Promise.all(
                 result.toolCalls.map(async (tc) => {
@@ -992,27 +1000,54 @@ class LLMSession {
                 );
                 result = await this._llm.generate(this, providerOptions, logOptions);
             } else {
-                // everything failed
-                /** @type {LLMCallPreset} */
-                const overrideChoice = typeof providerOptions === 'string'
-                    ? {
-                        preset: providerOptions,
-                        toolChoice: 'none'
-                    }
-                    : {
-                        ...providerOptions,
-                        toolChoice: 'none'
-                    };
-                result = await this._llm.generate(this, overrideChoice, logOptions);
+                // everything failed - force a final text answer without tools
+                this._llm.log.error(
+                    `LLMSession: all ${result.toolCalls.length} tool call(s) failed in round ${rounds}, `
+                    + 'forcing a tool-less final answer',
+                    { toolCalls: result.toolCalls }
+                );
+                result = await this._generateWithoutTools(providerOptions, logOptions);
+                break;
             }
         }
 
+        // safety net: if the model is still requesting tools (e.g. it hit the
+        // round limit), force one final tool-less generation so we never return
+        // 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}), `
+                + 'dropping pending tool calls and forcing a tool-less final answer',
+                { toolCalls: result.toolCalls }
+            );
+            result = await this._generateWithoutTools(providerOptions, logOptions);
+        }
+
         this._generatedIndex = this._chat.length;
         this._chat.push(result);
 
         return result;
     }
 
+    /**
+     *
+     * @param {LLMCallPreset} providerOptions
+     * @param {LLMLogOptions} logOptions
+     * @returns {Promise<LLMMessage<any>>}
+     */
+    _generateWithoutTools (providerOptions, logOptions) {
+        const overrideChoice = typeof providerOptions === 'string'
+            ? {
+                preset: providerOptions,
+                toolChoice: 'none'
+            }
+            : {
+                ...providerOptions,
+                toolChoice: 'none'
+            };
+        return this._llm.generate(this, overrideChoice, logOptions);
+    }
+
     /**
      *
      * @param {ToolCall} toolCall
@@ -1145,6 +1180,10 @@ class LLMSession {
      * @returns {LLMMessage[]}
      */
     static toMessages (result) {
+        // tool-call / structured messages carry no text content - nothing to send
+        if (typeof result.content !== 'string') {
+            return [];
+        }
         let filtered = result.content
             .replace(/\n\n\n+/g, '\n\n')
             .split(/\n\n+(?!\s*-)/g)

package/.claude/settings.local.json

@@ -1,11 +0,0 @@
-{
-  "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)"
-    ]
-  }
-}