wingbot 3.75.9-alpha.1 → 3.75.9-alpha.3

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/jsconfig.json

@@ -1,7 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "lib": ["es2019", "es2020.promise", "es2020.bigint", "es2020.string", "dom"],
+        "lib": ["es2019", "es2020.promise", "es2020.bigint", "es2020.string", "es2022.error", "dom"],
         "target": "ESNext",
         "allowSyntheticDefaultImports": true,
         "checkJs": true,

package/package.json

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

package/src/ChatGpt.js

@@ -373,7 +373,8 @@ class ChatGpt {
                     type: 'json_schema',
                     json_schema: {
                         name,
-                        schema
+                        schema,
+                        strict: true
                     }
                 };
             } else if (typeof responseFormat === 'string') {

package/src/LLMRouter.js

@@ -143,7 +143,7 @@ class LLMRouter {
                 .object({
                     action: LLMType.string()
                         .description('recommended action')
-                }, 'conversation routing information')
+                }, 'conversation_routing_information')
                 .toJSON();
         }
         return LLMRouter._cachedStructuredOutput;
@@ -159,12 +159,34 @@ class LLMRouter {
     static defaultRoute (prompt) {
         /** @type {RouterResolver} */
         const route = async (llm, req, routing) => {
-            const res = await llm.session('routing')
+            const session = llm.session('routing')
                 .setData(routing)
-                .systemPrompt(prompt)
-                .generateStructured(LLMRouter.structuredOutput());
+                .systemPrompt(prompt);
 
-            if (!routing.byAction.has(LLMRouter._normByAction(res.action))) {
+            const userText = typeof req?.text === 'function' ? req.text() : null;
+            if (userText) {
+                session.user(userText);
+            }
+
+            let res;
+            try {
+                res = await session.generateStructured(LLMRouter.structuredOutput());
+            } catch (e) {
+                // Fail closed: any error in routing classification is treated
+                // as "no context change" so the user's current flow continues.
+                // Surfaces to Sentry via the host-configured logger.
+                llm.log?.error('LLMRouter classification failed', e, {
+                    // userText,
+                    candidateActions: routing?.byAction
+                        ? Array.from(routing.byAction.keys())
+                        : [],
+                    senderId: req?.senderId ?? null,
+                    pageId: req?.pageId ?? null
+                });
+                return null;
+            }
+
+            if (!res || !routing.byAction.has(LLMRouter._normByAction(res.action))) {
                 return null;
             }
 
@@ -226,6 +248,10 @@ class LLMRouter {
         });
     }
 
+    /**
+     * @param {string} act
+     * @returns {string}
+     */
     static _normByAction (act) {
         return act.replace(/^\/|\/$/g, '');
     }

package/src/LLMSession.js

@@ -118,7 +118,6 @@ const stateData = require('./utils/stateData');
  * @prop {string} name - The function name
  * @prop {string} [description] - What the function does
  * @prop {FnParamsObject} [parameters] - Parameter schema
- * @prop {boolean} [strict]
  */
 
 /**
@@ -351,19 +350,15 @@ class LLMSession {
             .map(({
                 name,
                 description = null,
-                parameters = {},
-                strict = true
+                parameters = {}
             }) => ({
                 name,
                 ...(description && { description }),
-                ...(typeof strict === 'boolean' ? { strict } : {}),
+                strict: true,
                 parameters: {
                     type: 'object',
                     properties: {},
                     additionalProperties: false,
-                    required: 'properties' in parameters
-                        ? Object.keys(parameters.properties)
-                        : [],
                     ...parameters
                 }
             }));
@@ -847,7 +842,14 @@ class LLMSession {
                 responseFormat
             }, logOptions);
 
-            return JSON.parse(result.content);
+            try {
+                return JSON.parse(result.content);
+            } catch (e) {
+                throw new Error(
+                    `LLM structured output is not valid JSON: ${e.message}. Raw content: ${JSON.stringify(result.content)}`,
+                    { cause: e }
+                );
+            }
         });
         return this;
     }

package/src/LLMType.js

@@ -196,10 +196,11 @@ class LLMType {
     }
 
     /**
-     * Marks field as optional when used as an object property.
+     * Marks field as optional when used as an object property. In the
+     * generated schema this surfaces as a nullable type (e.g. `['string', 'null']`)
+     * — strict mode still requires the key to be present, just allows `null`.
      *
-     * When used outside object-property context, it has no practical effect,
-     * because requiredness is evaluated by parent object schemas.
+     * Outside an object-property context it has no practical effect.
      *
      * @example
      * const input = LLMType.object({
@@ -215,10 +216,9 @@ class LLMType {
     }
 
     /**
-     * Returns JSON Schema representation.
-     *
-     * For object schemas, nested properties are resolved recursively by calling
-     * `toJSON()` on each nested `LLMType` instance.
+     * Returns JSON Schema representation in OpenAI strict-mode form:
+     * every property is listed in `required`, and properties marked
+     * `optional()` are made nullable instead of being dropped from `required`.
      *
      * @example
      * const schema = LLMType.object({
@@ -246,18 +246,18 @@ class LLMType {
                 const properties = {};
                 const required = [];
                 Object.entries(this._properties).forEach(([key, child]) => {
-                    properties[key] = child.toJSON();
-                    if (child._required) {
-                        required.push(key);
+                    const childSchema = child.toJSON();
+                    if (!child._required) {
+                        childSchema.type = [childSchema.type, 'null'];
                     }
+                    properties[key] = childSchema;
+                    required.push(key);
                 });
 
                 schema.type = 'object';
                 schema.properties = properties;
                 schema.additionalProperties = false;
-                if (required.length > 0) {
-                    schema.required = required;
-                }
+                schema.required = required;
                 break;
             }