wingbot 3.74.0 → 3.74.1

package/src/LLM.js

@@ -8,6 +8,16 @@ const { PHONE_REGEX, EMAIL_REGEX } = require('./systemEntities/regexps');
 const getCondition = require('./utils/getCondition');
 const stateData = require('./utils/stateData');
 const Ai = require('./Ai');
+const {
+    PRESET_DEFAULT,
+    PRESET_ROUTING,
+    PRESET_EMBEDDINGS,
+    ROLE_USER,
+    ROLE_ASSISTANT,
+    ROLE_SYSTEM,
+    FILTER_SCOPE_CONVERSATION
+} = require('./LLMConsts');
+const LLMSession = require('./LLMSession');
 // const getCondition = require('./utils/getCondition');
 
 /** @typedef {import('./Responder')} Responder */
@@ -19,7 +29,10 @@ const Ai = require('./Ai');
 /** @typedef {import('./LLMSession').ToolCall} ToolCall */
 /** @typedef {import('./LLMSession').LLMRole} LLMRole */
 /** @typedef {import('./LLMSession').FilterScope} FilterScope */
-/** @typedef {import('./LLMSession')} LLMSession */
+/** @typedef {import('./LLMSession').JsonSchemaProp} JsonSchemaProp */
+/** @typedef {import('./LLMSession').JsonSchemaProp} SimpleJsonSchema */
+/** @typedef {import('./LLMSession').ToolFunction} ToolFunction */
+
 /** @typedef {import('./transcript/transcriptFromHistory').Transcript} Transcript */
 /** @typedef {import('./utils/getCondition').ConditionDefinition} ConditionDefinition */
 /** @typedef {import('./utils/getCondition').ConditionContext} ConditionContext */
@@ -74,12 +87,24 @@ const Ai = require('./Ai');
  * @callback LLMChatProviderPrompt
  * @param {LLMMessage[]} prompt
  * @param {LLMProviderOptions} [options]
+ * @param {ToolFunction[]} [tools]
  * @returns {Promise<LLMMessage>}
  */
 
+/**
+ * @typedef {object} ForcedFn
+ * @prop {'function'|string} [type]
+ * @prop {string} name
+ */
+
 /**
  * @typedef {object} LLMProviderOptions
  * @prop {string} [model]
+ * @prop {boolean} [parallelToolCalls]
+ * @prop {'auto'|'required'|'none'|ForcedFn|string} [toolChoice]
+ * @prop {'none'|'low'|'medium'|'high'|string} [reasoningEffort]
+ * @prop {'low'|'medium'|'high'|string} [verbosity]
+ * @prop {'text'|SimpleJsonSchema} [responseFormat]
  */
 
 /**
@@ -95,15 +120,29 @@ const Ai = require('./Ai');
 /** @typedef {import('node-fetch').default} Fetch */
 
 /**
- * @typedef {object} LLMConfiguration
- * @prop {LLMChatProvider} provider
- * @prop {string} [model]
+ * @typedef {object} LLMOptionsExt
  * @prop {number} [transcriptLength=-5]
  * @prop {'gpt'|string} [transcriptFlag]
  * @prop {boolean} [transcriptAnonymize]
+ */
+
+/** @typedef {LLMOptionsExt & LLMProviderOptions} LLMOptions */
+/** @typedef {LLMOptions & { preset?: LLMPresetName}} LLMCallOptions */
+/** @typedef {'default'|'routing'|'embeddings'|string} LLMPresetName */
+
+/** @typedef {LLMCallOptions|LLMPresetName} LLMCallPreset */
+
+/**
+ * @typedef {object} LLMGlobalConfigExt
+ * @prop {LLMChatProvider} provider
  * @prop {Persona|string|null} [persona]
  * @prop {LLMLogger} [logger]
  * @prop {boolean} [disableLLM]
+ * @prop {{ [key: LLMPresetName]: LLMOptions }} [presets]
+ */
+
+/**
+ * @typedef {LLMGlobalConfigExt & LLMOptions} LLMGlobalConfig
  */
 
 /**
@@ -129,6 +168,12 @@ const Ai = require('./Ai');
  * @prop {LogPrompt} logPrompt
  */
 
+/**
+ * @typedef {object} Logger
+ * @prop {Function} log
+ * @prop {Function} error
+ */
+
 /**
  * @typedef {object} VectorSearchDocument
  * @property {string} id
@@ -148,19 +193,28 @@ const Ai = require('./Ai');
  */
 class LLM {
 
+    /** @type {LLMPresetName} */
+    static PRESET_DEFAULT = PRESET_DEFAULT;
+
+    /** @type {LLMPresetName} */
+    static PRESET_ROUTING = PRESET_ROUTING;
+
+    /** @type {LLMPresetName} */
+    static PRESET_EMBEDDINGS = PRESET_EMBEDDINGS;
+
     /** @type {LLMRole} */
-    static ROLE_USER = 'user';
+    static ROLE_USER = ROLE_USER;
 
     /** @type {LLMRole} */
-    static ROLE_ASSISTANT = 'assistant';
+    static ROLE_ASSISTANT = ROLE_ASSISTANT;
 
     /** @type {LLMRole} */
-    static ROLE_SYSTEM = 'system';
+    static ROLE_SYSTEM = ROLE_SYSTEM;
 
     static GPT_FLAG = 'gpt';
 
     /** @type {FilterScope} */
-    static FILTER_SCOPE_CONVERSATION = 'conversation';
+    static FILTER_SCOPE_CONVERSATION = FILTER_SCOPE_CONVERSATION;
 
     static EVALUATION_ACTIONS = {
         DISCARD: '_DISCARD'
@@ -174,11 +228,20 @@ class LLM {
 
     /**
      *
-     * @param {LLMConfiguration} configuration
+     * @param {LLMGlobalConfig} configuration
      * @param {Ai} ai
+     * @param {Logger} [log=console]
      */
-    constructor (configuration, ai) {
-        const { provider, ...rest } = configuration;
+    constructor (configuration, ai, log = console) {
+        const {
+            provider,
+            presets = {},
+            transcriptFlag = null,
+            transcriptLength = 5,
+            transcriptAnonymize = false,
+            model = null,
+            ...rest
+        } = configuration;
 
         this._configuration = {
             transcriptFlag: null,
@@ -190,6 +253,30 @@ class LLM {
             ...rest
         };
 
+        /** @type {LLMOptions} */
+        const defaultPreset = {
+            model,
+            transcriptFlag,
+            transcriptLength,
+            transcriptAnonymize
+        };
+
+        this._presets = new Map(
+            Object.entries(presets)
+                .map(([k, v]) => [k, {
+                    ...defaultPreset,
+                    ...v
+                }])
+        );
+
+        if (!this._presets.has(LLM.PRESET_DEFAULT)) {
+            this._presets.set(LLM.PRESET_DEFAULT, defaultPreset);
+        }
+
+        if (!this._presets.has(LLM.PRESET_ROUTING)) {
+            this._presets.set(LLM.PRESET_ROUTING, defaultPreset);
+        }
+
         /** @type {LLMChatProvider} */
         this._provider = provider;
 
@@ -197,6 +284,8 @@ class LLM {
 
         /** @type {LLMMessage} */
         this._lastResult = null;
+
+        this.log = log;
     }
 
     /**
@@ -214,20 +303,51 @@ class LLM {
     }
 
     /**
-     * @returns {Omit<LLMConfiguration, 'provider'>}
+     * @deprecated
+     * @returns {Omit<LLMGlobalConfig, 'provider'>}
      */
     get configuration () {
         return this._configuration;
     }
 
+    /**
+     * @returns {LLMSession}
+     */
+    session () {
+        return new LLMSession(this);
+    }
+
     /**
      *
-     * @param {Partial<LLMConfiguration>} override
+     * @param {LLMCallPreset} [requestedPreset]
      */
-    setSessionConfig (override) {
-        Object.assign(this._configuration, override);
+    llmOptions (requestedPreset = LLM.PRESET_DEFAULT) {
+        let preset;
+        let override;
+
+        if (typeof requestedPreset === 'string') {
+            preset = requestedPreset;
+        } else {
+            ({ preset = LLM.PRESET_DEFAULT, ...override } = requestedPreset);
+        }
+
+        if (!this._presets.has(preset)) {
+            throw new Error(`LLM Preset '${preset}' does not exist.`);
+        }
+        return {
+            ...this._presets.get(preset),
+            ...override
+        };
     }
 
+    // /**
+    //  *
+    //  * @param {Partial<LLMConfiguration>} override
+    //  */
+    // setSessionConfig (override) {
+    //     Object.assign(this._configuration, override);
+    // }
+
     /**
      *
      * @param {Transcript[]} chat
@@ -250,19 +370,14 @@ class LLM {
     /**
      *
      * @param {LLMSession} session
-     * @param {LLMProviderOptions} [options={}]
+     * @param {LLMCallPreset} [preset={}]
      * @param {LLMLogOptions} [logOptions]
      * @returns {Promise<LLMMessage>}
      */
-    async generate (session, options = {}, logOptions = {}) {
-        /** @type {LLMProviderOptions} */
-        const opts = {
-            ...(this._configuration.model && { model: this._configuration.model }),
-            ...options
-        };
-
-        const prompt = session.toArray(true);
-        const result = await this._provider.requestChat(prompt, opts);
+    async generate (session, preset = {}, logOptions = {}) {
+        const opts = this.llmOptions(preset);
+        const prompt = await session.toArray(true);
+        const result = await this._provider.requestChat(prompt, opts, session.tools);
         this.logPrompt(prompt, result, logOptions.vectorSearchResult);
         return result;
     }
@@ -280,29 +395,6 @@ class LLM {
         });
     }
 
-    /**
-     *
-     * @param {LLMMessage} result
-     * @returns {LLMMessage[]}
-     */
-    static toMessages (result) {
-        let filtered = result.content
-            .replace(/\n\n\n+/g, '\n\n')
-            .split(/\n\n+(?!\s*-)/g)
-            .map((t) => t.replace(/\s*\n\s+/g, '\n')
-                .trim())
-            .filter((t) => !!t);
-
-        if (result.finishReason === 'length' && filtered.length <= 0) {
-            filtered = filtered.slice(0, filtered.length - 1);
-        }
-
-        return filtered.map((content) => ({
-            content,
-            role: result.role
-        }));
-    }
-
     /**
      *
      * @param {EvaluationRule[]} rules

package/src/LLMConsts.js

@@ -0,0 +1,42 @@
+/**
+ * @author David Menger
+ */
+'use strict';
+
+/** @typedef {import('./LLMSession').FilterScope} FilterScope */
+/** @typedef {import('./LLM').LLMPresetName} LLMPresetName */
+/** @typedef {import('./LLMSession').LLMRole} LLMRole */
+
+/** @type {LLMPresetName} */
+const PRESET_DEFAULT = 'default';
+
+/** @type {LLMPresetName} */
+const PRESET_ROUTING = 'routing';
+
+/** @type {LLMPresetName} */
+const PRESET_EMBEDDINGS = 'embeddings';
+
+/** @type {LLMRole} */
+const ROLE_USER = 'user';
+
+/** @type {LLMRole} */
+const ROLE_ASSISTANT = 'assistant';
+
+/** @type {LLMRole} */
+const ROLE_SYSTEM = 'system';
+
+const GPT_FLAG = 'gpt';
+
+/** @type {FilterScope} */
+const FILTER_SCOPE_CONVERSATION = 'conversation';
+
+module.exports = {
+    PRESET_DEFAULT,
+    PRESET_ROUTING,
+    PRESET_EMBEDDINGS,
+    ROLE_USER,
+    ROLE_ASSISTANT,
+    ROLE_SYSTEM,
+    GPT_FLAG,
+    FILTER_SCOPE_CONVERSATION
+};

package/src/LLMMockProvider.js

@@ -35,9 +35,36 @@ class LLMMockProvider {
      */
     // eslint-disable-next-line no-unused-vars
     async requestChat (prompt, options) {
+
         if (prompt.length === 0) {
             throw new Error('Empty prompt');
         }
+
+        if (prompt.some((p) => p?.content?.includes('THROW EXCEPTION'))) {
+            throw new Error('THROW EXCEPTION');
+        }
+
+        if (prompt.some((p) => p.toolCallId)) {
+            return {
+                role: LLM.ROLE_ASSISTANT,
+                content: 'got tool call id'
+            };
+        }
+
+        if (prompt.some((p) => p?.content?.includes('CALL MOCK TOOL'))) {
+            return {
+                role: LLM.ROLE_ASSISTANT,
+                toolCalls: [
+                    {
+                        id: `${Date.now()}${Math.floor(Math.random() * 10)}`,
+                        type: 'function',
+                        name: 'mock',
+                        args: JSON.stringify({ mock: true })
+                    }
+                ]
+            };
+        }
+
         // const stats = prompt.reduce((o, m) => Object.assign(o, {
         //    [m.role]: (o[m.role] || 0) + 1
         // }), { system: 0, assistant: 0, user: 0 });
@@ -55,13 +82,47 @@ class LLMMockProvider {
         //    content: `${statsText} > ${LLMMockProvider.DEFAULT_MODEL}: ${prompt.map((m) => m.content).join(' ')}`
         // };
 
+        const text = `${options.model || LLMMockProvider.DEFAULT_MODEL}:${prompt.filter((m) => m.content).map((m) => `[${m.role}] ${m.content}`).join(' | ')}`;
+
         return {
             role: LLM.ROLE_ASSISTANT,
             finishReason: 'length',
-            content: `${options.model || LLMMockProvider.DEFAULT_MODEL}:${prompt.map((m) => m.content).join(' ')}`
+            content: options.responseFormat && options.responseFormat !== 'text'
+                ? JSON.stringify(this._mockFromSchema(options.responseFormat))
+                : text
         };
     }
 
+    _mockFromSchema (schema) {
+        if (schema.properties) {
+            const obj = {};
+            for (const [key, prop] of Object.entries(schema.properties)) {
+                obj[key] = this._mockFromProp(prop);
+            }
+            return obj;
+        }
+        return {};
+    }
+
+    _mockFromProp (prop) {
+        if (prop.enum) {
+            return prop.enum[0];
+        }
+        switch (prop.type) {
+            case 'number':
+                return prop.minimum || 0;
+            case 'boolean':
+                return false;
+            case 'array':
+                return [];
+            case 'object':
+                return this._mockFromSchema(prop);
+            case 'string':
+            default:
+                return 'mock';
+        }
+    }
+
 }
 
 module.exports = LLMMockProvider;