wingbot 3.76.18 → 3.77.0-alpha.1

package/src/Processor.js

@@ -14,6 +14,7 @@ const { prepareState, mergeState, isUserInteraction } = require('./utils/stateVa
 const LLM = require('./LLM');
 const LLMMockProvider = require('./LLMMockProvider');
 const LLMDispatcher = require('./LLMDispatcher');
+const logSpan = require('./utils/logSpan');
 
 /** @typedef {import('./wingbot/CustomEntityDetectionModel').Intent} Intent */
 /** @typedef {import('./ReducerWrapper')} ReducerWrapper */
@@ -85,12 +86,7 @@ const LLMDispatcher = require('./LLMDispatcher');
  * @type {InteractionEvent}
  */
 
-/**
- * @typedef {object} ILogger
- * @prop {Function} log
- * @prop {Function} warn
- * @prop {Function} error
- */
+/** @typedef {import('./log/types').LevelLogger} ILogger */
 
 /**
  *
@@ -314,7 +310,7 @@ class Processor extends EventEmitter {
 
     async _reportError (pageId, err, event, senderId = null) {
         if (err.code === 204) {
-            this.options.log.log(`nothing sent: ${err.message}`, event);
+            this.options.log.debug('nothing sent', { message: err.message, senderId, pageId });
             return;
         }
         if (err.code !== 403) {
@@ -335,7 +331,9 @@ class Processor extends EventEmitter {
 
             await this.stateStorage.saveState(state);
         } catch (e) {
-            this.options.log.error(`failed to log error "${err.message}" because: ${e.message}`, e, err);
+            this.options.log.error('Failed to store the send error to the state', e, {
+                senderId, pageId, sendError: err.message
+            });
         }
     }
 
@@ -364,6 +362,20 @@ class Processor extends EventEmitter {
         ),
         responderData = {}
     ) {
+        const senderId = message && ((message.sender && message.sender.id)
+            || (message.optin && message.optin.user_ref));
+
+        // one span per processed event: its logs, LLM and storage calls share
+        // the operation, and the span carries the conversation (senderId)
+        return logSpan(
+            this.options.log,
+            'wingbot processMessage',
+            () => this._handleMessage(message, pageId, messageSender, responderData),
+            { senderId, pageId }
+        );
+    }
+
+    async _handleMessage (message, pageId, messageSender, responderData) {
         const preloadPromise = this._preload();
 
         try {
@@ -1052,7 +1064,9 @@ class Processor extends EventEmitter {
                         this.stateStorage
                             .getState(senderId, pageId)
                             .then((state) => {
-                                this.options.log.warn(`Locked state: ${senderId}, lock: ${lock}, at ${Date.now()}`, state);
+                                this.options.log.warn('Locked state', {
+                                    senderId, pageId, lock, state
+                                });
                             })
                             .catch(() => {});
 
@@ -1085,7 +1099,9 @@ class Processor extends EventEmitter {
             const duration = Date.now() - now;
             if (duration >= (this.options.waitForLockedState / 2)) {
                 try {
-                    this.options.log.warn(`Loading state (${senderId}) for timeout ${timeout} took too long (${duration}ms).`);
+                    this.options.log.warn('Loading state took too long', {
+                        senderId, pageId, timeout, durationMs: duration
+                    });
                 } catch (e) {
                     // noop
                 }

package/src/Responder.js

@@ -253,6 +253,9 @@ class Responder {
 
         /** @typedef {PromptSource|Promise<string>} PromptContextItem */
 
+        /** @type {Set<string>} - ids of the tools placed in the interactions, the request passed */
+        this._llmTools = new Set();
+
         /** @type {Map<string,PromptContextItem[]>} */
         this._llmContext = new Map([
             [this.LLM_CTX_DEFAULT, []],
@@ -301,6 +304,28 @@ class Responder {
         return this;
     }
 
+    /**
+     * Makes a tool (registered with plugins.registerTool()) available to the LLM,
+     * which talks to the user in this request (prompt messages, plugins using LLMToolRunner)
+     * - like the instructions, the tools are collected on the way to the interaction
+     *
+     * @param {string} toolId
+     * @returns {this}
+     */
+    llmAddTool (toolId) {
+        this._llmTools.add(toolId);
+        return this;
+    }
+
+    /**
+     * Ids of the tools added in this request (in the order they were added)
+     *
+     * @returns {string[]}
+     */
+    llmTools () {
+        return [...this._llmTools];
+    }
+
     /**
      *
      * @param {LLMFilter|LLMFilterFn} filter

package/src/analytics/GA4.js

@@ -126,7 +126,7 @@ class GA4 {
         };
 
         if (this._options.debug) {
-            this._logger.log('GA4: starting session', event);
+            this._logger.debug('GA4: starting session', event);
         }
 
         const query = Object.entries(event)
@@ -255,15 +255,15 @@ class GA4 {
 
             message = (validationMessages[0] || { description: message }).description;
         } catch (e) {
-            this._logger.log('GA4 debug failed', e);
+            this._logger.warn('GA4 debug failed', e);
             message += ` +(${e.message})`;
         }
 
         if (validationMessages.length || message) {
-            this._logger.log('GA4: validationMessages', validationMessages);
+            this._logger.debug('GA4: validationMessages', { validationMessages });
             this._logger.error(`GA4: fail: ${message} [${res ? res.status : 0}]`, params.body);
         } else {
-            this._logger.log(`GA4: debug [${res ? res.status : 0}]`, params.body);
+            this._logger.debug('GA4: debug', { status: res ? res.status : 0, body: params.body });
         }
     }
 

package/src/graphApi/GraphApi.js

@@ -28,11 +28,7 @@ const DEFAULT_CACHE = 86400000; // 24 hours
 /** @typedef {import('../CallbackAuditLog')} AuditLog */
 /** @typedef {import('graphql')} GqlLib */
 
-/**
- * @typedef {object} Logger
- * @prop {Function} log
- * @prop {Function} error
- */
+/** @typedef {import('../log/types').LevelLogger} Logger */
 
 class GraphApi {
 

package/src/graphApi/gqlRules.js

@@ -10,11 +10,7 @@ const {
 
 /** @typedef {import('graphql').ValidationRule} ValidationRule */
 
-/**
- * @typedef {object} Logger
- * @prop {Function} log
- * @prop {Function} error
- */
+/** @typedef {import('../log/types').LevelLogger} Logger */
 
 /**
  *
@@ -58,7 +54,7 @@ function gqlRules (variables, isProduction, hideVerboseErrors, log = console) {
             // This can be used for logging or to implement rate limiting
             onComplete: (complexity) => {
                 if (!isProduction) {
-                    log.log('Determined query complexity: ', complexity);
+                    log.debug('Determined query complexity', { complexity });
                 }
             },
 
@@ -70,7 +66,7 @@ function gqlRules (variables, isProduction, hideVerboseErrors, log = console) {
                     log.error(msg);
                     return new GraphQLError('');
                 }
-                log.log(msg);
+                log.warn('GQL Query too complex', { actual, max });
                 return new GraphQLError(`Query is too complex: ${actual}. Maximum allowed complexity: ${max}`);
             },
 

package/src/log/types.js

@@ -0,0 +1,161 @@
+// GENERATED COPY of wingbot-super/packages/log/src/types.js - do not edit here.
+// Edit packages/log, then run: node packages/log/scripts/copy.mjs packages/wingbot-llm
+/**
+ * @author wingbot.ai
+ *
+ * The types of a log call, shared by the logger and the libraries that get
+ * it (wingbot, the orchestrator). Types only, no code: `scripts/copy.mjs`
+ * copies this file into the apps (next to the logger) and into the
+ * libraries (targets.json, `files: ["types"]`), so they import
+ * `LevelLogger` instead of declaring their own `Logger`.
+ */
+'use strict';
+
+/**
+ * A log call: `(message, [Error], [data...])`, the arguments in any order.
+ * The first Error is the exception, plain objects are merged into the data,
+ * other values go to `data.args`.
+ *
+ * Rules for every log call:
+ * 1. **The message is a constant**, the values go to the data:
+ *    `log.warn('SAP getList failed', { status, taskType })`, not
+ *    `` `SAP getList failed ${status}` ``. Never put `e.stack` or
+ *    `JSON.stringify(...)` into the message: pass the Error, pass the object.
+ *    (Only the first line, max 200 chars, becomes the message / App Insights
+ *    event name; the rest goes to `fullMessage`.)
+ * 2. **Log once, where the error is handled.** An adapter (SapApi,
+ *    MicrosoftApi) does not log a failure it throws: it calls
+ *    `log.annotate({...})` and throws an Error with the context
+ *    (`new Error(msg, { cause })`). The code that decides what happens (retry
+ *    later, show an error, return 500) logs it once. Logging the same Error
+ *    object again is marked as a duplicate and not reported again.
+ * 3. **Never log** a raw request / event, headers, cookies, tokens or config:
+ *    use `requestLogInfo(event)`. Secret-looking keys, the `queryKeys` and the
+ *    configured secret values are redacted anyway, but do not rely on it.
+ *    Personal data (emails, transcripts) is allowed. How much data:
+ *    - `debug`: the detail, whole objects too (the task, the slot, the
+ *      transcript). It is written with `verbose`, or with the error of the
+ *      trace (`replayOnError`), and cut by `redact` (`maxString`, `maxDepth`,
+ *      `maxArray`).
+ *    - `info`: the ids and the small values that explain the event (statuses,
+ *      reason, emails), not whole objects: it is always written.
+ *    - `warn` / `error`: what is needed to fix it, whole objects too.
+ * 4. **Wrap non-HTTP work** (worker runs, sync runs, queues) in `log.span()`,
+ *    and call `await log.sendAndClose()` at the end of a lambda or worker run
+ *    (it flushes only on Lambda; `{ force: true }` before the process exits).
+ * 5. **One row per business event.** A storage read or write that must be
+ *    audited is `log.audit()`, other detail is `debug`. The decision about a
+ *    task or slot (created, rejected and why, status changed) is one `info`
+ *    row with the ids.
+ *
+ * @callback LogFn
+ * @param {any} message - a CONSTANT text: values go to the data, never `e.stack`
+ *  or `JSON.stringify(...)` in it (only its first line, max 200 chars, is kept as
+ *  the message). An Error is accepted too.
+ * @param {...any} args - the Error (pass it, do not stringify it) and data objects
+ *  (`slotId`, `taskId`, ...; whole objects in `debug`, `warn` and `error`).
+ *  Never a raw request, event, headers, tokens or config: use
+ *  `requestLogInfo(event)`.
+ * @returns {void}
+ */
+
+/**
+ * The role of a span (OpenTelemetry SpanKind). App Insights picks the table
+ * by it: `server` and `consumer` are AppRequests (the start of an operation:
+ * an HTTP request, a worker run taken from a timer or a queue), the others are
+ * AppDependencies (`client`: a call to another system, `internal`: a step).
+ *
+ * @typedef {'internal'|'server'|'client'|'producer'|'consumer'} SpanKindName
+ */
+
+/**
+ * @typedef {object} SpanOptions
+ * @prop {SpanKindName} [kind] default `internal`
+ */
+
+/**
+ * @typedef {<T>(
+ *  name: string, fn: () => T|Promise<T>, attrs?: object, options?: SpanOptions
+ * ) => Promise<T>} SpanFn
+ */
+
+/**
+ * A call to another system (SAP, Microsoft Graph, KSRM ...), see `log.httpCall()`.
+ *
+ * @typedef {object} HttpCall
+ * @prop {string} [method] `GET`, `POST` ...
+ * @prop {string|null} [url] the full URL (query secrets are redacted)
+ * @prop {Record<string, any>} [params] the small values that tell what the
+ *  call is about (query parameters, ids, type, language)
+ * @prop {Record<string, any>|null} [headers] the request headers, when
+ *  `send()` is not axios (axios: the headers it sent are read from the
+ *  response); secret headers are redacted
+ * @prop {any} [body] the request body (redacted, cut at 8000 characters)
+ * @prop {Record<string, any>} [data] more fields of the row (ECS
+ *  `eventAction` ...)
+ */
+
+/**
+ * What `toResponse` reads; what it leaves out is read like an axios response
+ * (`status`, `data`, `headers`, `config.headers`).
+ *
+ * @typedef {object} HttpCallResponse
+ * @prop {number|null} [status] the HTTP status
+ * @prop {any} [body] the response body
+ * @prop {Record<string, any>|null} [headers] the response headers
+ * @prop {Record<string, any>|null} [requestHeaders] the headers that were sent
+ */
+
+/**
+ * @template R
+ * @typedef {object} HttpCallOptions
+ * @prop {(res: R) => HttpCallResponse} [toResponse] reads the status, the body
+ *  and the headers of what `send()` returns (and of `error.response`), or
+ *  changes the body for the log
+ */
+
+/**
+ * `httpCall(name, send, call, options)`, like `span(name, fn, data, options)`.
+ * The name is the span name and the message of the row, a constant per
+ * operation: `SAP getListVA`, `Graph sendMail` (not the URL, it has ids).
+ *
+ * @typedef {<R>(
+ *  name: string, send: () => Promise<R>, call?: HttpCall, options?: HttpCallOptions<R>
+ * ) => Promise<R>} HttpCallFn
+ */
+
+/**
+ * What a library needs from a logger: the five levels. `console`, the shared
+ * logger (lib/log of an app) and the orchestrator's moduleLoggerFactory
+ * logger have them. `span` is optional: the shared logger has it, a library
+ * checks it before the call (`console` has none).
+ *
+ * Use it in a library as the typedef
+ * `{import('./log/types').LevelLogger} Logger`.
+ *
+ * @typedef {object} LevelLogger
+ * @prop {LogFn} error **Someone must act**: a bug, lost or wrong data, an
+ *  upstream call that failed after the retries, a business result that was not
+ *  saved. Goes to App Insights (AppEvents, AppExceptions) and to Sentry, and
+ *  triggers the error alerts, so do NOT use it for client mistakes or for
+ *  handled states. Log it once, where the error is handled: an adapter that
+ *  throws calls `log.annotate()` instead.
+ *  Examples: a result written to the wrong row, `Bot preloader is not set`,
+ *  SAP setResult failed after the retries.
+ * @prop {LogFn} warn **Degraded, but handled**: a 4xx from a client (bad
+ *  body, invalid token), a transient upstream error before a retry, a discarded
+ *  LLM reply, a duplicate-key retry, a fallback that was used.
+ *  Examples: `HTTP 400 POST /api`, SAP timeout (next run retries), #CANARY.
+ * @prop {LogFn} info **Business events and expected states**: a slot opened,
+ *  a task synced, an email sent, a test whitelist block, a missing translation.
+ *  Dropped unless `verbose` (verboseLog in config). AppTraces.
+ * @prop {LogFn} log like `info`, but always written (AppEvents). Kept for the
+ *  old call sites; prefer `info` (an event worth seeing in production) or
+ *  `debug` (detail).
+ * @prop {LogFn} debug **Detail**: payloads, request / response bodies, step by
+ *  step flow. Dropped unless `verbose`.
+ * @prop {SpanFn} [span] Runs `fn` in a child span (the shared logger only):
+ *  see `LogFunctions.span` of the shared logger.
+ */
+
+module.exports = {};

package/src/notifications/Notifications.js

@@ -110,11 +110,7 @@ const DEFAULT_CAMPAIGN_DATA = {
  * @prop {object} meta
  */
 
-/**
- * @typedef {object} Logger
- * @prop {Function} log
- * @prop {Function} error
- */
+/** @typedef {import('../log/types').LevelLogger} Logger */
 
 /** @typedef {import('./api/notificationsApiFactory').NotificationsApiOptions} ApiOptions */
 

package/src/resolvers/index.js

@@ -18,11 +18,13 @@ const setState = require('./setState');
 const expectedInput = require('./expectedInput');
 const skip = require('./skip');
 const contextMessage = require('./contextMessage');
+const llmTool = require('./llmTool');
 
 module.exports = {
     path,
     message,
     contextMessage,
+    llmTool,
     include,
     postback,
     expected,

package/src/resolvers/llmTool.js

@@ -0,0 +1,41 @@
+/*
+ * @author Ondrej Veres
+ */
+'use strict';
+
+const Router = require('../Router');
+const getCondition = require('../utils/getCondition');
+
+/** @typedef {import('../BuildRouter').BotContext<any>} BotContext */
+/** @typedef {import('../Router').Resolver<any>} Resolver */
+/** @typedef {import('../utils/getCondition').ConditionDefinition} ConditionDefinition */
+
+/**
+ * @typedef {object} LlmToolParamsBase
+ * @property {string} toolId - id of a tool registered with plugins.registerTool()
+ */
+
+/** @typedef {LlmToolParamsBase & ConditionDefinition} LlmToolParams */
+
+/**
+ * Makes a tool available to the LLM, which talks to the user - like the instructions
+ * (contextMessage), it's collected on the way to the interaction
+ * (in the root - everywhere, in a dialog - only there)
+ *
+ * @param {LlmToolParams} params
+ * @param {BotContext} context
+ * @returns {Resolver}
+ */
+function llmTool (params, context) {
+    const { toolId } = params;
+    const condition = getCondition(params, context, `LLM tool "${toolId}"`);
+
+    return async (req, res) => {
+        if (toolId && await condition(req, res)) {
+            res.llmAddTool(toolId);
+        }
+        return Router.CONTINUE;
+    };
+}
+
+module.exports = llmTool;

package/src/resolvers/message.js

@@ -22,6 +22,7 @@ const {
 const { vars, VAR_TYPES } = require('../utils/stateVariables');
 const LLM = require('../LLM');
 const canaryLog = require('../utils/canaryLog');
+const LLMToolRunner = require('../LLMToolRunner');
 
 /** @typedef {import('../Responder').VoiceControl} VoiceControl */
 /** @typedef {import('../BuildRouter').LinksMap} LinksMap */
@@ -317,9 +318,10 @@ function selectTranslation (resolverId, params, texts, data) {
  * @param {"message" | "prompt"} [params.type]
  * @param {string} [params.llmContextType]
  * @param {BotContext} context
+ * @param {import('../Plugins')} [plugins] - code of the LLM tools placed in the interactions
  * @returns {Resolver}
  */
-function message (params, context = {}) {
+function message (params, context = {}, plugins = null) {
     const {
         // @ts-ignore
         isLastIndex, isLastMessage, linksMap, configuration, resolverId
@@ -457,23 +459,62 @@ function message (params, context = {}) {
             let session;
             let evaluation;
             let discard;
+            let llmError;
+
+            // the tools placed on the way to this interaction ("LLM Tool" blocks)
+            const tools = new LLMToolRunner(req, res, {
+                // @ts-ignore
+                blocks: context.blocks,
+                plugins,
+                log: context.log,
+                allowForbiddenSnippetWords: context.allowForbiddenSnippetWords,
+                source: 'prompt'
+            });
 
             try {
                 session = res.llmSessionWithHistory(params.llmContextType);
-                await session.systemPrompt(text)
-                    .generate();
+                tools.attach(session);
+                // a button of a tool - its tool runs the same way, as when the LLM calls it
+                await tools.handleButton(session);
+                if (!tools.postBackAction && !session.isStoppedSync()) {
+                    await session.systemPrompt(text)
+                        .generate(tools.generateOptions(session));
+                }
+
+                if (tools.postBackAction) {
+                    // a situation with a target - the conversation continues in its interaction
+                    postBack(tools.postBackAction);
+                    return Router.END;
+                }
+
+                if (session.isStoppedSync()) {
+                    // a tool took over the conversation (session.stop()) - nothing more is sent
+                    return Router.END;
+                }
 
                 evaluation = await res.llmEvaluate(session, params.llmContextType);
                 ({ discard } = evaluation);
             } catch (e) {
                 (context.log || console).error(`LLM ERR: ${e.message} [${req.senderId}]`, e);
+                llmError = e;
                 discard = true;
             }
 
             if (discard) {
+                // short summary: where it happened, what the LLM generated,
+                // what is sent instead and why (every rule with its score)
                 canaryLog(context.log, context.canaryLogs, 'LLM discarded', {
-                    evaluation,
-                    session
+                    reason: llmError ? 'llm-error' : 'rule-matched',
+                    ...(llmError && { error: llmError.message }),
+                    source: {
+                        resolverId,
+                        action: req.action(),
+                        contextType: params.llmContextType || null
+                    },
+                    generated: (llmError ? null : session?.lastResponseSync()) || null,
+                    fallbackText: text,
+                    threshold: evaluation?.threshold ?? null,
+                    rules: evaluation?.evaluated ?? []
                 });
             } else {
 
@@ -490,6 +531,11 @@ function message (params, context = {}) {
 
                 res.setFlag(LLM.GPT_FLAG);
 
+                if (tools.quickReplies.length) {
+                    // quick replies of the tools go with the answer of the LLM
+                    sendReplies = [...(sendReplies || []), ...tools.quickReplies];
+                }
+
                 const lastMessageI = messages.length - 1;
                 messages.forEach((m, i) => {
                     if (lastMessageI === i) {

package/src/utils/canaryLog.js

@@ -3,12 +3,7 @@
  */
 'use strict';
 
-/**
- * @typedef {object} ILogger
- * @prop {Function} log
- * @prop {Function} warn
- * @prop {Function} error
- */
+/** @typedef {import('../log/types').LevelLogger} ILogger */
 
 /**
  *

package/src/utils/logSpan.js

@@ -0,0 +1,36 @@
+/**
+ * @author wingbot.ai
+ */
+'use strict';
+
+/**
+ * @typedef {object} SpanLogger
+ * @prop {<T>(name: string, fn: () => T|Promise<T>, attributes?: object) => Promise<T>} [span]
+ */
+
+/**
+ * Runs `fn` in a span of the app logger, when the logger has `span()`
+ * (the shared wingbot logger: an OpenTelemetry span, App Insights and Sentry).
+ * Other loggers (console) only run `fn`.
+ *
+ * The attributes without a value are left out.
+ *
+ * @template T
+ * @param {SpanLogger|any} log
+ * @param {string} name
+ * @param {() => T|Promise<T>} fn
+ * @param {Record<string, any>} [attributes]
+ * @returns {Promise<T>}
+ */
+async function logSpan (log, name, fn, attributes = {}) {
+    if (!log || typeof log.span !== 'function') {
+        return fn();
+    }
+    const attrs = Object.keys(attributes)
+        .filter((key) => attributes[key] !== undefined && attributes[key] !== null)
+        .reduce((o, key) => Object.assign(o, { [key]: attributes[key] }), {});
+
+    return log.span(name, fn, attrs);
+}
+
+module.exports = logSpan;

package/src/utils/pathUtils.js

@@ -45,8 +45,14 @@ function parseActionPayload (object, needRawData = false) {
         let isObject = typeof payload === 'object' && payload !== null;
 
         if (typeof payload === 'string' && payload.match(/^\s*\{.*\}\s*$/)) {
-            payload = JSON.parse(payload);
-            isObject = true;
+            try {
+                payload = JSON.parse(payload);
+                isObject = true;
+            } catch (e) {
+                if (!(e instanceof SyntaxError)) throw e;
+                // broken JSON from the client: an unknown action, not a 500
+                // (the action check below rejects the raw string)
+            }
         }
 
         if (isObject) {

package/src/wingbot/CachedModel.js

@@ -98,7 +98,11 @@ class CachedModel extends CustomEntityDetectionModel {
             .filter((e) => this._entityDetectors.has(e.entity)
                 && this._entityDetectors.get(e.entity).clearOverlaps);
 
-        if (this._options.verbose) this._log.log(`#NLP: ${text} [before]`, { before, intents, entities });
+        if (this._options.verbose) {
+            this._log.debug('#NLP before', {
+                text, before, intents, entities
+            });
+        }
 
         [intents, entities] = this._attachEntities(intents, entities, before, expectedEntities);
 
@@ -106,11 +110,19 @@ class CachedModel extends CustomEntityDetectionModel {
             .filter((e) => !this._entityDetectors.has(e.entity)
                 || !this._entityDetectors.get(e.entity).clearOverlaps);
 
-        if (this._options.verbose) this._log.log(`#NLP: ${text} [after]`, { after, intents, entities });
+        if (this._options.verbose) {
+            this._log.debug('#NLP after', {
+                text, after, intents, entities
+            });
+        }
 
         [intents, entities] = this._attachEntities(intents, entities, after);
 
-        if (this._options.verbose) this._log.log(`#NLP: ${text} [attached]`, { intents, entities, expectedEntities });
+        if (this._options.verbose) {
+            this._log.debug('#NLP attached', {
+                text, intents, entities, expectedEntities
+            });
+        }
 
         return {
             text: local.text,

package/src/wingbot/CustomEntityDetectionModel.js

@@ -304,7 +304,7 @@ class CustomEntityDetectionModel {
             return zLen - aLen;
         });
 
-        if (this._options.verbose) this._log.log('#NLP [nonOverlapping]', { entities, expectedEntities, justDuplicates });
+        if (this._options.verbose) this._log.debug('#NLP [nonOverlapping]', { entities, expectedEntities, justDuplicates });
 
         let res = [];
 
@@ -354,7 +354,7 @@ class CustomEntityDetectionModel {
                         const othersConflict = res.some((e) => putback === e
                             || (e.start < putback.end && e.end > putback.start));
 
-                        this._log.log(`#NLP (${i}|${k} [putBack: ${entity.entity}|${putback.entity}] (${i}|${k})`, {
+                        this._log.debug(`#NLP (${i}|${k} [putBack: ${entity.entity}|${putback.entity}] (${i}|${k})`, {
                             putback, entity, currentConflict, othersConflict
                         });
 
@@ -366,7 +366,7 @@ class CustomEntityDetectionModel {
             }
 
             if (this._options.verbose) {
-                this._log.log(`#NLP (${i}) [nonOverlapping| ${entity.entity}:${entity.value}]`, {
+                this._log.debug(`#NLP (${i}) [nonOverlapping| ${entity.entity}:${entity.value}]`, {
                     willRemoveEntity: overlapping, overlapping, duplicate, isExpected, entity
                 });
             }