wingbot 3.73.15 → 3.74.1

package/src/LLMTool.js

@@ -0,0 +1,56 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+/** @typedef {import('./LLMSession').Tool} Tool */
+/** @typedef {import('./LLMSession').ToolInput} ToolInput */
+/** @typedef {import('./LLMSession').ObjectTool} ObjectTool */
+/** @typedef {import('./LLMSession').ToolFunctionInput} ToolFunctionInput */
+/** @typedef {import('./LLMSession').ToolFnCallback} ToolFnCallback */
+/** @typedef {import('./LLMSession').ToolFunction} ToolFunction */
+/** @typedef {import('./LLMSession').FnParamsObject} FnParamsObject */
+/** @typedef {import('./LLMSession').SimpleJsonSchema} SimpleJsonSchema */
+
+/** @typedef {string[]} Enum */
+
+/**
+ * @typedef {{}} SchemaDefinition
+ */
+
+/**
+ * @class LLMTool
+ */
+class LLMTool {
+
+    /**
+     *
+     * @param {ToolFnCallback} fn
+     * @param {ToolFunctionInput} options
+     * @returns {ObjectTool}
+     */
+    static create (fn, {
+        name = fn.name,
+        ...rest
+    }) {
+        let {
+            parameters = {
+                properties: {}
+            }
+        } = rest;
+
+        if ('toJSON' in parameters && typeof parameters.toJSON === 'function') {
+            parameters = parameters.toJSON();
+        }
+
+        return {
+            fn,
+            name,
+            ...rest,
+            parameters
+        };
+    }
+
+}
+
+module.exports = LLMTool;

package/src/LLMType.js

@@ -0,0 +1,331 @@
+'use strict';
+
+/**
+ * Lightweight fluent builder for JSON Schema definitions used by LLM tools.
+ *
+ * @class LLMType
+ */
+class LLMType {
+
+    /**
+     * @param {'string'|'number'|'enum'|'boolean'|'array'|'object'} type
+     * @param {object} [config]
+     * @param {string[]} [config.values]
+     * @param {LLMType} [config.items]
+     * @param {{ [key: string]: LLMType }} [config.properties]
+     * @param {string} [config.name]
+     */
+    constructor (type, {
+        values = null,
+        items = null,
+        properties = null,
+        name = null
+    } = {}) {
+        this._type = type;
+        this._name = name;
+
+        this._description = null;
+        this._min = null;
+        this._max = null;
+
+        this._required = true;
+
+        this._values = values;
+        this._items = items;
+        this._properties = properties;
+    }
+
+    /**
+     * Creates a string schema.
+     *
+     * @example
+     * const title = LLMType.string()
+     *   .description('Short title')
+     *   .min(1)
+     *   .max(64);
+     *
+     * @returns {LLMType}
+     */
+    static string () {
+        return new LLMType('string');
+    }
+
+    /**
+     * Creates a number schema.
+     *
+     * @example
+     * const temperature = LLMType.number()
+     *   .description('Temperature in Celsius')
+     *   .min(-40)
+     *   .max(100);
+     *
+     * @returns {LLMType}
+     */
+    static number () {
+        return new LLMType('number');
+    }
+
+    /**
+     * Creates an enum schema.
+     *
+     * @example
+     * const tone = LLMType.enum(['formal', 'casual'])
+     *   .description('Response tone');
+     *
+     * @param {string[]} values
+     * @returns {LLMType}
+     */
+    static enum (values) {
+        if (!Array.isArray(values) || values.length === 0 || !values.every((v) => typeof v === 'string')) {
+            throw new Error('LLMType.enum(values) expects a non-empty array of strings');
+        }
+        return new LLMType('enum', { values: [...values] });
+    }
+
+    /**
+     * Creates a boolean schema.
+     *
+     * @example
+     * const includeSummary = LLMType.boolean()
+     *   .description('Whether summary should be included');
+     *
+     * @returns {LLMType}
+     */
+    static boolean () {
+        return new LLMType('boolean');
+    }
+
+    /**
+     * Creates an array schema with one item type.
+     *
+     * @example
+     * const tags = LLMType.array(LLMType.string().min(1))
+     *   .description('List of tags')
+     *   .min(1)
+     *   .max(20);
+     *
+     * @param {LLMType} itemType
+     * @returns {LLMType}
+     */
+    static array (itemType) {
+        if (!(itemType instanceof LLMType)) {
+            throw new Error('LLMType.array(itemType) expects itemType to be LLMType');
+        }
+        return new LLMType('array', { items: itemType });
+    }
+
+    /**
+     * Creates an object schema from named `LLMType` properties.
+     * Properties are required by default unless `optional()` is called.
+     *
+     * @example
+     * const user = LLMType.object({
+     *   name: LLMType.string().description('User name'),
+     *   age: LLMType.number().optional()
+     * });
+     *
+     * @param {{ [key: string]: LLMType }} properties
+     * @param {string} [name=null]
+     * @returns {LLMType}
+     */
+    static object (properties = {}, name = null) {
+        if (!properties || typeof properties !== 'object' || Array.isArray(properties)) {
+            throw new Error('LLMType.object(properties) expects an object');
+        }
+        const entries = Object.entries(properties);
+        for (const [key, value] of entries) {
+            if (!(value instanceof LLMType)) {
+                throw new Error(`LLMType.object(properties) expects property "${key}" to be LLMType`);
+            }
+        }
+        return new LLMType('object', { properties: { ...properties }, name });
+    }
+
+    /**
+     * Sets human-readable field description.
+     *
+     * @example
+     * const schema = LLMType.string().description('Display name');
+     *
+     * @param {string} text
+     * @returns {this}
+     */
+    description (text) {
+        this._description = text;
+        return this;
+    }
+
+    /**
+     * Sets minimum boundary and maps it to a type-specific JSON Schema keyword.
+     *
+     * Mapping:
+     * - string/enum -> `minLength`
+     * - number -> `minimum`
+     * - array -> `minItems`
+     * - object -> `minProperties`
+     *
+     * @example
+     * const schema = LLMType.array(LLMType.string()).min(2);
+     *
+     * @param {number} value
+     * @returns {this}
+     */
+    min (value) {
+        this._min = value;
+        return this;
+    }
+
+    /**
+     * Sets maximum boundary and maps it to a type-specific JSON Schema keyword.
+     *
+     * Mapping:
+     * - string/enum -> `maxLength`
+     * - number -> `maximum`
+     * - array -> `maxItems`
+     * - object -> `maxProperties`
+     *
+     * @example
+     * const schema = LLMType.number().max(100);
+     *
+     * @param {number} value
+     * @returns {this}
+     */
+    max (value) {
+        this._max = value;
+        return this;
+    }
+
+    /**
+     * Marks field as optional when used as an object property.
+     *
+     * When used outside object-property context, it has no practical effect,
+     * because requiredness is evaluated by parent object schemas.
+     *
+     * @example
+     * const input = LLMType.object({
+     *   query: LLMType.string(),
+     *   locale: LLMType.string().optional()
+     * });
+     *
+     * @returns {this}
+     */
+    optional () {
+        this._required = false;
+        return this;
+    }
+
+    /**
+     * Returns JSON Schema representation.
+     *
+     * For object schemas, nested properties are resolved recursively by calling
+     * `toJSON()` on each nested `LLMType` instance.
+     *
+     * @example
+     * const schema = LLMType.object({
+     *   query: LLMType.string().min(1),
+     *   limit: LLMType.number().optional()
+     * }).toJSON();
+     *
+     * @returns {object}
+     */
+    toJSON () {
+        const schema = this._baseSchema();
+
+        switch (this._type) {
+            case 'enum':
+                schema.type = 'string';
+                schema.enum = this._values;
+                break;
+
+            case 'array':
+                schema.type = 'array';
+                schema.items = this._items.toJSON();
+                break;
+
+            case 'object': {
+                const properties = {};
+                const required = [];
+                Object.entries(this._properties).forEach(([key, child]) => {
+                    properties[key] = child.toJSON();
+                    if (child._required) {
+                        required.push(key);
+                    }
+                });
+
+                schema.type = 'object';
+                schema.properties = properties;
+                schema.additionalProperties = false;
+                if (required.length > 0) {
+                    schema.required = required;
+                }
+                break;
+            }
+
+            default:
+                schema.type = this._type;
+        }
+
+        this._applyMinMax(schema);
+        return schema;
+    }
+
+    /**
+     * @returns {object}
+     */
+    _baseSchema () {
+        return /** @type {object} */ ({
+            ...(this._description !== null && { description: this._description }),
+            ...(this._name !== null && { name: this._name })
+        });
+    }
+
+    /**
+     * @param {object} schema
+     */
+    _applyMinMax (schema) {
+        if (this._min === null && this._max === null) {
+            return;
+        }
+
+        const target = schema;
+
+        let minKey = null;
+        let maxKey = null;
+
+        switch (this._type) {
+            case 'string':
+            case 'enum':
+                minKey = 'minLength';
+                maxKey = 'maxLength';
+                break;
+
+            case 'number':
+                minKey = 'minimum';
+                maxKey = 'maximum';
+                break;
+
+            case 'array':
+                minKey = 'minItems';
+                maxKey = 'maxItems';
+                break;
+
+            case 'object':
+                minKey = 'minProperties';
+                maxKey = 'maxProperties';
+                break;
+
+            default:
+                return;
+        }
+
+        if (this._min !== null) {
+            target[minKey] = this._min;
+        }
+        if (this._max !== null) {
+            target[maxKey] = this._max;
+        }
+    }
+
+}
+
+module.exports = LLMType;

package/src/Processor.js

@@ -21,7 +21,7 @@ const LLMMockProvider = require('./LLMMockProvider');
 /** @typedef {import('./analytics/consts').TrackingCategory} TrackingCategory */
 /** @typedef {import('./analytics/consts').TrackingType} TrackingType */
 /** @typedef {import('./analytics/consts').ResponseFlag} ResponseFlag */
-/** @typedef {import('./LLM').LLMConfiguration} LLMConfiguration */
+/** @typedef {import('./LLM').LLMGlobalConfig} LLMGlobalConfig */
 
 /**
  * @typedef {object} AutoTypingConfig
@@ -113,7 +113,7 @@ const LLMMockProvider = require('./LLMMockProvider');
  * @prop {string} [apiUrl] - Url for calling orchestrator API
  * @prop {Function} [fetch] - Fetch function for calling orchestrator API
  * @prop {number} [sessionDuration] - Session duration for analytic purposes
- * @prop {LLMConfiguration} [llm] - LLM model configuration
+ * @prop {LLMGlobalConfig} [llm] - LLM model configuration
  * @prop {Preloader<R>} [preloader]
  */
 
@@ -405,19 +405,19 @@ class Processor extends EventEmitter {
             return { status: 304 };
         }
 
-        /** @type {LLMConfiguration} */
-        const llmOptions = {
+        /** @type {LLMGlobalConfig} */
+        const llmConfiguration = {
             provider: new LLMMockProvider(),
             ...this.options.llm
         };
 
         if (typeof messageSender.logPrompt === 'function') {
-            Object.assign(llmOptions, {
+            Object.assign(llmConfiguration, {
                 logger: messageSender
             });
         }
 
-        const llm = new LLM(llmOptions, Ai.ai);
+        const llm = new LLM(llmConfiguration, Ai.ai, this.options.log);
 
         const result = await this
             ._dispatch(message, pageId, messageSender, responderData, preloadPromise, llm);

package/src/Responder.js

@@ -34,7 +34,7 @@ const EXCEPTION_HOPCOUNT_THRESHOLD = 5;
 /** @typedef {import('./transcript/transcriptFromHistory').Transcript} Transcript */
 /** @typedef {import('./analytics/consts').TrackingType} TrackingType */
 
-/** @typedef {import('./LLM').LLMConfiguration} LLMConfiguration */
+/** @typedef {import('./LLM').LLMCallPreset} LLMCallPreset */
 /** @typedef {import('./LLM').PreprocessedRule} PreprocessedRule */
 /** @typedef {import('./LLM').EvaluationRuleAction} EvaluationRuleAction */
 /** @typedef {import('./LLM').EvaluationResult} EvaluationResult */
@@ -42,6 +42,8 @@ const EXCEPTION_HOPCOUNT_THRESHOLD = 5;
 /** @typedef {import('./LLMSession').LLMFilterFn} LLMFilterFn */
 /** @typedef {import('./LLMSession').LLMFilter} LLMFilter */
 /** @typedef {import('./LLMSession').FilterScope} FilterScope */
+/** @typedef {import('./LLMSession').LLMMessageSrc} LLMMessageSrc */
+/** @typedef {import('./LLMSession').AsyncLLMMessage} AsyncLLMMessage */
 /** @typedef {import('./utils/stateData').IStateRequest} IStateRequest */
 
 /**
@@ -63,6 +65,7 @@ Object.freeze(ExpectedInput);
  * @prop {string} [webview_height_ratio]
  * @prop {string} [onCloseAction]
  * @prop {string} [onCloseActionData]
+ * @prop {number} [max_length]
  */
 
 /**
@@ -355,13 +358,34 @@ class Responder {
         return this;
     }
 
-    async llmSession (contextType = this.LLM_CTX_DEFAULT) {
+    /**
+     *
+     * @param {string} contextType
+     * @returns {AsyncLLMMessage}
+     */
+    async _getSystemMessagesForType (contextType) {
         const system = await this._getSystemContentForType(contextType);
+        return system.map((content) => ({ role: LLM.ROLE_SYSTEM, content }));
+    }
 
-        const chat = system.map((content) => ({ role: LLM.ROLE_SYSTEM, content }));
+    /**
+     *
+     * @param {string} contextType
+     * @returns {Promise<LLMSession>}
+     */
+    async llmSession (contextType = this.LLM_CTX_DEFAULT) {
+        const system = this._getSystemMessagesForType(contextType);
 
         const filters = this._filtersForContext(contextType);
-        return new LLMSession(this.llm, chat, this._llmSend.bind(this), filters);
+        return new LLMSession(this.llm, [system], this._llmSend.bind(this), filters);
+    }
+
+    /**
+     *
+     * @returns {LLMSession}
+     */
+    llmSessionEmpty () {
+        return new LLMSession(this.llm, [], this._llmSend.bind(this));
     }
 
     /**
@@ -372,7 +396,7 @@ class Responder {
      */
     async llmEvaluate (session, contextType = this.LLM_CTX_DEFAULT) {
         const rules = this._llmResultRules.get(contextType) || [];
-        const text = session.lastResponse();
+        const text = session.lastResponseSync();
 
         if (rules.length === 0 || !text) {
             return {
@@ -449,38 +473,35 @@ class Responder {
         return resolved;
     }
 
-    async llmSessionWithHistory (
+    /**
+     *
+     * @param {'default'|string} contextType
+     * @param {LLMCallPreset} callPreset
+     * @returns {LLMSession}
+     */
+    llmSessionWithHistory (
         contextType = this.LLM_CTX_DEFAULT,
-        transcriptLength = undefined,
-        transcriptFlag = undefined
+        callPreset = undefined
     ) {
         const {
             transcriptAnonymize,
-            transcriptFlag: transcriptFlagCfg,
-            transcriptLength: transcriptLengthCfg
-        } = this.llm.configuration;
-
-        const computedTranscriptLength = transcriptLength === undefined
-            ? transcriptLengthCfg
-            : transcriptLength;
-        const computedTranscriptFlag = transcriptFlag === undefined
-            ? transcriptFlagCfg : transcriptFlag;
-
-        const [systems, transcript] = await Promise.all([
-            this._getSystemContentForType(contextType),
-            this.getTranscript(
-                computedTranscriptLength,
-                computedTranscriptFlag
-            )
-        ]);
-
-        const chat = [
-            ...systems.map((content) => ({ role: LLM.ROLE_SYSTEM, content })),
-            ...LLM.anonymizeTranscript(transcript, transcriptAnonymize)
-        ];
+            transcriptFlag,
+            transcriptLength
+        } = this.llm.llmOptions(callPreset);
 
         const filters = this._filtersForContext(contextType);
-        return new LLMSession(this.llm, chat, this._llmSend.bind(this), filters);
+        return new LLMSession(this.llm, [
+            this._getSystemMessagesForType(contextType),
+            this._getTranscriptMessages(transcriptLength, transcriptFlag, transcriptAnonymize)
+        ], this._llmSend.bind(this), filters);
+    }
+
+    async _getTranscriptMessages (transcriptLength, transcriptFlag, transcriptAnonymize) {
+        const transcript = await this.getTranscript(
+            transcriptLength,
+            transcriptFlag
+        );
+        return LLM.anonymizeTranscript(transcript, transcriptAnonymize);
     }
 
     /**
@@ -1188,6 +1209,7 @@ class Responder {
      * After processing the user input, next requests will be processed as usual,
      *
      * @param {ExpectedInput} [expectedInput]
+     * @param {ExpectedInputOptions} [options]
      * @returns {this}
      * @example
      *
@@ -1213,9 +1235,9 @@ class Responder {
      *         .setState({ cardNumber });
      * });
      */
-    expectedConfidentInput (expectedInput = null) {
-        if (expectedInput) {
-            this.expectedInput(expectedInput);
+    expectedConfidentInput (expectedInput = null, options = undefined) {
+        if (expectedInput || options) {
+            this.expectedInput(expectedInput, options);
         }
         return this.setState({
             _expectedConfidentInput: true

package/src/Router.js

@@ -7,8 +7,13 @@ const { pathToRegexp } = require('path-to-regexp');
 const ReducerWrapper = require('./ReducerWrapper');
 const { makeAbsolute } = require('./utils');
 
-const Responder = require('./Responder'); // eslint-disable-line no-unused-vars
-const Request = require('./Request'); // eslint-disable-line no-unused-vars
+/** @typedef {import('./Responder')} Responder */
+
+/**
+ * @template {object} [S=object]
+ * @template {BaseConfiguration} [C=object]
+ * @typedef {import('./Request')<S, C>} Request
+ */
 
 function defaultPathContext () {
     return { globalIntentsMeta: {}, path: '/*' };

package/src/graphApi/validateBotApi.js

@@ -21,7 +21,12 @@ const apiAuthorizer = require('./apiAuthorizer');
  */
 async function validate (bot, validationRequestBody, postBackTest = null, textTest = null) {
     try {
-        bot.buildWithSnapshot(validationRequestBody.blocks, Number.MAX_SAFE_INTEGER);
+        bot.buildWithSnapshot(
+            validationRequestBody.blocks,
+            Number.MAX_SAFE_INTEGER,
+            undefined,
+            validationRequestBody.deployedConfiguration
+        );
     } catch (e) {
         const error = `Bot build failed: ${e.message}`;
         // eslint-disable-next-line no-console

package/src/resolvers/expectedInput.js

@@ -5,13 +5,22 @@
 
 const Router = require('../Router');
 
-function expectedInput ({ type = null, confident = false }, { isLastIndex }) {
+function expectedInput ({ type = null, confident = false, maxLength = null }, { isLastIndex }) {
 
     return (req, res) => {
+        const opts = {};
+
+        const useMaxLen = maxLength && parseInt(`${maxLength}`, 10);
+        if ((!type || type === 'password') && useMaxLen) {
+            Object.assign(opts, {
+                max_length: useMaxLen
+            });
+        }
+
         if (confident) {
             res.expectedConfidentInput(type);
         } else if (type) {
-            res.expectedInput(type);
+            res.expectedInput(type, opts);
         }
 
         return isLastIndex ? Router.END : Router.CONTINUE;

package/src/resolvers/message.js

@@ -455,8 +455,7 @@ function message (params, context = {}) {
             let discard;
 
             try {
-                session = await res.llmSessionWithHistory(params.llmContextType);
-
+                session = res.llmSessionWithHistory(params.llmContextType);
                 await session.systemPrompt(text)
                     .generate();
 
@@ -483,7 +482,7 @@ function message (params, context = {}) {
                 //    // no response?
                 // }
 
-                const messages = session.messagesToSend();
+                const messages = session.messagesToSendSync();
 
                 res.setFlag(LLM.GPT_FLAG);
 

package/.claude/settings.local.json

@@ -1,9 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npm run:*)",
-      "Bash(npx mocha:*)",
-      "mcp__ide__getDiagnostics"
-    ]
-  }
-}