wingbot 3.76.2 → 3.76.4-alpha.1

package/.claude/settings.local.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.76.2",
+  "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;
     }
 

package/src/LLMType.js

@@ -249,6 +249,13 @@ class LLMType {
                     const childSchema = child.toJSON();
                     if (!child._required) {
                         childSchema.type = [childSchema.type, 'null'];
+                        // A nullable enum must also list null among its allowed
+                        // values — otherwise null satisfies `type` but fails `enum`
+                        // and is effectively disallowed, forcing the model to pick
+                        // a value for an optional field.
+                        if (Array.isArray(childSchema.enum) && !childSchema.enum.includes(null)) {
+                            childSchema.enum = [...childSchema.enum, null];
+                        }
                     }
                     properties[key] = childSchema;
                     required.push(key);