wingbot 3.76.3 → 3.76.4-alpha.2

package/package.json

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

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>>}
@@ -224,6 +228,9 @@ class LLMSession {
         this._res = res || llm?.res;
 
         this._preset = preset;
+
+        /** @type {PossiblyAsyncContent|null} */
+        this._fallbackMessage = null;
     }
 
     /**
@@ -850,6 +857,38 @@ class LLMSession {
         return this;
     }
 
+    /**
+     * Sets a message to send to the user when a subsequent `generate()` call
+     * fails (e.g. a provider network timeout). Instead of rejecting - which
+     * would surface the raw error to the user - the failure is logged and this
+     * message is sent in place of the model's reply, so the chain resolves
+     * cleanly. If the message resolves to an empty value, the original error
+     * is rethrown (same as when no fallback is set).
+     *
+     * Only affects `generate()`. `generateStructured()` keeps using delegated
+     * errors (see {@link onDelegatedError}).
+     *
+     * @param {PossiblyAsyncContent} content
+     * @returns {this}
+     */
+    setFallbackMessage (content) {
+        this._job(() => {
+            this._fallbackMessage = content;
+        }, true);
+        return this;
+    }
+
+    /**
+     * @returns {Promise<string>}
+     */
+    async _resolveFallbackContent () {
+        const fallback = this._fallbackMessage;
+        const content = typeof fallback === 'function'
+            ? fallback(this._resolveData())
+            : fallback;
+        return Promise.resolve(content);
+    }
+
     /**
      *
      * @param {LLMCallPreset} [providerOptions]
@@ -857,7 +896,28 @@ class LLMSession {
      * @returns {this}
      */
     generate (providerOptions = this._preset, logOptions = {}) {
-        this._job(() => this._generate(providerOptions, logOptions));
+        this._job(async () => {
+            try {
+                return await this._generate(providerOptions, logOptions);
+            } catch (e) {
+                if (this._fallbackMessage === null) {
+                    throw e;
+                }
+
+                const content = await this._resolveFallbackContent();
+                if (!content) {
+                    // no usable fallback message - propagate the original error
+                    throw e;
+                }
+                this._llm.log.error(`LLMSession.generate failed, sending fallback message: ${e.message}`, e);
+
+                /** @type {LLMMessage} */
+                const result = { role: ROLE_ASSISTANT, content };
+                this._generatedIndex = this._chat.length;
+                this._chat.push(result);
+                return result;
+            }
+        });
         return this;
     }
 
@@ -914,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) => {
@@ -936,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
@@ -1089,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)