wingbot 3.76.4-alpha.1 → 3.76.4-alpha.3

package/package.json

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

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/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)