wingbot 3.75.9-alpha.4 → 3.75.9-alpha.5

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.75.9-alpha.4",
+  "version": "3.75.9-alpha.5",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "type": "commonjs",

package/src/ChatGpt.js

@@ -341,6 +341,10 @@ class ChatGpt {
         });
 
         let body;
+        let responseData;
+        let responseText;
+        let status;
+        let statusText;
         try {
             let lastUserIndex = 0;
             let totalTokens = messages
@@ -445,26 +449,26 @@ class ChatGpt {
                 body: JSON.stringify(body)
             });
 
-            /** @type {ChatGPTResponse} */
-            const data = await response.json();
+            ({ status, statusText } = response);
 
-            if (response.status !== 200
-                || !Array.isArray(data.choices)) {
-                const { status, statusText } = response;
+            responseText = await response.text();
+            /** @type {ChatGPTResponse} */
+            responseData = JSON.parse(responseText);
 
-                this._logger.error('#GPT failed', {
-                    status, statusText, data, body
-                });
+            if (status !== 200
+                || !Array.isArray(responseData.choices)) {
                 throw new Error(`Chat GPT ${status}`);
             }
 
-            const [choice] = data.choices;
+            const [choice] = responseData.choices;
 
-            this._log('#GPT response', { choice, data });
+            this._log('#GPT response', { choice, responseData });
 
             return choice;
         } catch (e) {
-            this._logger.error('#GPT failed', e, body);
+            this._logger.log('#GPT failed', {
+                message: e.message, body, responseText, responseData, status, statusText
+            });
             throw e;
         }
     }

package/src/LLM.js

@@ -294,12 +294,34 @@ class LLM {
         /** @type {LLMMessage} */
         this._lastResult = null;
 
+        /** @type {Error|null} */
+        this._delegatedError = null;
+
         this.log = log;
 
         this.req = null;
         this.res = null;
     }
 
+    /**
+     * @param {Error|null} [error]
+     */
+    setDelegatedError (error = null) {
+        this._delegatedError = error;
+    }
+
+    /**
+     * @param {boolean} [reset=false]
+     * @returns {boolean}
+     */
+    hasDelegatedError (reset = false) {
+        const has = this._delegatedError !== null;
+        if (reset && has) {
+            this._delegatedError = null;
+        }
+        return has;
+    }
+
     setReqRes (req, res) {
         this.req = req;
         this.res = res;

package/src/LLMSession.js

@@ -791,6 +791,49 @@ class LLMSession {
         return this;
     }
 
+    /**
+     * If there is a delegated error on the LLM instance, appends (or replaces)
+     * a system message with `prompt` and resets the delegated error.
+     * If `prompt` resolves to an empty string, nothing happens.
+     *
+     * @param {PossiblyAsyncContent} prompt
+     * @param {boolean} [replaceCurrent=false]
+     * @returns {this}
+     */
+    onDelegatedError (prompt, replaceCurrent = false) {
+        this._job(async () => {
+            if (!this._llm.hasDelegatedError()) {
+                return;
+            }
+
+            const content = typeof prompt === 'function'
+                ? await Promise.resolve(prompt())
+                : await Promise.resolve(prompt);
+
+            if (!content) {
+                return;
+            }
+
+            if (replaceCurrent) {
+                const lastSystemIdx = this._chat.reduceRight((found, msg, i) => {
+                    if (found !== -1) return found;
+                    if ('role' in msg && msg.role === ROLE_SYSTEM) return i;
+                    return found;
+                }, -1);
+                if (lastSystemIdx !== -1) {
+                    this._chat[lastSystemIdx] = { role: ROLE_SYSTEM, content };
+                } else {
+                    this._chat.push({ role: ROLE_SYSTEM, content });
+                }
+            } else {
+                this._chat.push({ role: ROLE_SYSTEM, content });
+            }
+
+            this._llm.setDelegatedError(null);
+        });
+        return this;
+    }
+
     /**
      *
      * @param {LLMFilter|LLMFilter[]} filter
@@ -836,19 +879,27 @@ class LLMSession {
         }
 
         this._job(async () => {
-            const result = await this._generate({
-                ...(typeof providerOptions === 'object' ? providerOptions : {}),
-                ...(typeof providerOptions === 'string' ? { preset: providerOptions } : {}),
-                responseFormat
-            }, logOptions);
-
             try {
-                return JSON.parse(result.content);
+                const result = await this._generate({
+                    ...(typeof providerOptions === 'object' ? providerOptions : {}),
+                    ...(typeof providerOptions === 'string' ? { preset: providerOptions } : {}),
+                    responseFormat
+                }, logOptions);
+
+                try {
+                    return JSON.parse(result.content);
+                } catch (e) {
+                    this._llm.log.error(`LLM structured output parse error (${responseFormat.name}): ${e.message}`, e, {
+                        rawContent: result.content
+                    });
+                    throw new Error(
+                        `LLM structured output is not valid JSON: ${e.message}. Raw content: ${JSON.stringify(result.content)}`,
+                        { cause: e }
+                    );
+                }
             } catch (e) {
-                throw new Error(
-                    `LLM structured output is not valid JSON: ${e.message}. Raw content: ${JSON.stringify(result.content)}`,
-                    { cause: e }
-                );
+                this._llm.setDelegatedError(e);
+                throw e;
             }
         });
         return this;

package/src/Responder.js

@@ -248,12 +248,14 @@ class Responder {
         this.llm = llm;
 
         this.LLM_CTX_DEFAULT = 'default';
+        this.LLM_ERROR = 'error';
 
         /** @typedef {PromptSource|Promise<string>} PromptContextItem */
 
         /** @type {Map<string,PromptContextItem[]>} */
         this._llmContext = new Map([
-            [this.LLM_CTX_DEFAULT, []]
+            [this.LLM_CTX_DEFAULT, []],
+            [this.LLM_ERROR, []]
         ]);
 
         /** @type {Map<string,PreprocessedRule[]>} */
@@ -373,18 +375,24 @@ class Responder {
      *
      * @param {string} contextType
      * @param {LLMCallPreset} [callPreset]
+     * @param {PossiblyAsyncContent} [errorPrompt]
      * @returns {LLMSession}
      */
-    llmSession (contextType = this.LLM_CTX_DEFAULT, callPreset = undefined) {
+    llmSession (contextType = this.LLM_CTX_DEFAULT, callPreset = undefined, errorPrompt = undefined) { // eslint-disable-line max-len
         const system = this._getSystemMessagesForType(contextType);
 
         const filters = this._filtersForContext(contextType);
-        return new LLMSession(this.llm, [system], {
+        const session = new LLMSession(this.llm, [system], {
             onSend: this._llmSend.bind(this),
             filters,
             preset: callPreset,
             res: this
         });
+        session.onDelegatedError(
+            errorPrompt ?? (() => this._getSystemContentForType(this.LLM_ERROR)
+                .then((parts) => parts.join('\n\n')))
+        );
+        return session;
     }
 
     /**
@@ -488,12 +496,14 @@ class Responder {
     /**
      *
      * @param {'default'|string} contextType
-     * @param {LLMCallPreset} callPreset
+     * @param {LLMCallPreset} [callPreset]
+     * @param {import('./LLMSession').PossiblyAsyncContent} [errorPrompt]
      * @returns {LLMSession}
      */
     llmSessionWithHistory (
         contextType = this.LLM_CTX_DEFAULT,
-        callPreset = undefined
+        callPreset = undefined,
+        errorPrompt = undefined
     ) {
         const {
             transcriptAnonymize,
@@ -502,7 +512,7 @@ class Responder {
         } = this.llm.llmOptions(callPreset);
 
         const filters = this._filtersForContext(contextType);
-        return new LLMSession(this.llm, [
+        const session = new LLMSession(this.llm, [
             this._getSystemMessagesForType(contextType),
             this._getTranscriptMessages(transcriptLength, transcriptFlag, transcriptAnonymize)
         ], {
@@ -511,6 +521,11 @@ class Responder {
             preset: callPreset,
             res: this
         });
+        session.onDelegatedError(
+            errorPrompt ?? (() => this._getSystemContentForType(this.LLM_ERROR)
+                .then((parts) => parts.join('\n\n')))
+        );
+        return session;
     }
 
     async _getTranscriptMessages (transcriptLength, transcriptFlag, transcriptAnonymize) {