wingbot 3.76.3 → 3.76.4-alpha.1

package/package.json

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

package/src/LLMSession.js

@@ -224,6 +224,9 @@ class LLMSession {
         this._res = res || llm?.res;
 
         this._preset = preset;
+
+        /** @type {PossiblyAsyncContent|null} */
+        this._fallbackMessage = null;
     }
 
     /**
@@ -850,6 +853,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 +892,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;
     }