@wabot-dev/framework 0.9.17 → 0.9.19

package/dist/src/addon/async/in-memory/InMemoryCronJobRepository.js

@@ -1,9 +1,29 @@
-import { __decorate } from 'tslib';
+import { __decorate, __metadata } from 'tslib';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { generate } from 'short-uuid';
 import { singleton } from '../../../core/injection/index.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import '../../../feature/async/AsyncMetadataStore.js';
+import '../../../feature/async/TransactionMetadataStore.js';
+import '../../../feature/async/Async.js';
+import { CronJob } from '../../../feature/async/CronJob.js';
+import '../../../core/error/setupErrorHandlers.js';
+import '../../../feature/async/JobRepository.js';
+import '../../../feature/async/JobRunner.js';
+import '../../../feature/async/JobScheduler.js';
+import '../../../feature/async/JobWatchdog.js';
+import '../../../feature/async/CronScheduler.js';
 
+const CRON_JOBS_FILE = '.wabot/in-memory/cron-jobs.json';
+const MAX_CRON_JOBS = 32;
+const logger = new Logger('wabot:in-memory-cron-job-repository');
 let InMemoryCronJobRepository = class InMemoryCronJobRepository {
+    // Insertion order acts as LRU: most-recently-touched at the end.
     items = new Map();
+    constructor() {
+        this.load();
+    }
     async create(cronJob) {
         if (cronJob.wasCreated())
             throw new Error('CronJob already created');
@@ -11,6 +31,8 @@ let InMemoryCronJobRepository = class InMemoryCronJobRepository {
         cronJob['data'].createdAt = new Date().getTime();
         cronJob.validate();
         this.items.set(cronJob.id, cronJob);
+        this.enforceLimit();
+        this.persist();
     }
     async findDue(date) {
         const now = (date ?? new Date()).getTime();
@@ -28,7 +50,8 @@ let InMemoryCronJobRepository = class InMemoryCronJobRepository {
         if (!cronJob.wasCreated())
             throw new Error('CronJob was not created');
         cronJob.validate();
-        this.items.set(cronJob.id, cronJob);
+        this.touch(cronJob);
+        this.persist();
     }
     async findByName(name) {
         for (const c of this.items.values()) {
@@ -37,9 +60,57 @@ let InMemoryCronJobRepository = class InMemoryCronJobRepository {
         }
         return null;
     }
+    touch(item) {
+        this.items.delete(item.id);
+        this.items.set(item.id, item);
+    }
+    enforceLimit() {
+        while (this.items.size > MAX_CRON_JOBS) {
+            const oldestKey = this.items.keys().next().value;
+            if (oldestKey === undefined)
+                break;
+            this.items.delete(oldestKey);
+        }
+    }
+    filePath() {
+        return path.resolve(process.cwd(), CRON_JOBS_FILE);
+    }
+    load() {
+        const file = this.filePath();
+        if (!fs.existsSync(file))
+            return;
+        try {
+            const raw = fs.readFileSync(file, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed))
+                return;
+            for (const data of parsed) {
+                if (!data?.id)
+                    continue;
+                const cronJob = new CronJob(data);
+                this.items.set(cronJob.id, cronJob);
+            }
+            this.enforceLimit();
+        }
+        catch (err) {
+            logger.warn(`Failed to load ${file}:`, err);
+        }
+    }
+    persist() {
+        const file = this.filePath();
+        try {
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            const data = [...this.items.values()].map((c) => c['data']);
+            fs.writeFileSync(file, JSON.stringify(data, null, 2), 'utf-8');
+        }
+        catch (err) {
+            logger.warn(`Failed to persist ${file}:`, err);
+        }
+    }
 };
 InMemoryCronJobRepository = __decorate([
-    singleton()
+    singleton(),
+    __metadata("design:paramtypes", [])
 ], InMemoryCronJobRepository);
 
 export { InMemoryCronJobRepository };

package/dist/src/addon/async/in-memory/InMemoryJobRepository.js

@@ -1,9 +1,29 @@
-import { __decorate } from 'tslib';
+import { __decorate, __metadata } from 'tslib';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { generate } from 'short-uuid';
 import { singleton } from '../../../core/injection/index.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import '../../../feature/async/AsyncMetadataStore.js';
+import '../../../feature/async/TransactionMetadataStore.js';
+import '../../../feature/async/Async.js';
+import '../../../_virtual/index.js';
+import { Job } from '../../../feature/async/Job.js';
+import '../../../feature/async/JobRepository.js';
+import '../../../feature/async/JobRunner.js';
+import '../../../feature/async/JobScheduler.js';
+import '../../../feature/async/JobWatchdog.js';
+import '../../../feature/async/CronScheduler.js';
 
+const JOBS_FILE = '.wabot/in-memory/jobs.json';
+const MAX_JOBS = 32;
+const logger = new Logger('wabot:in-memory-job-repository');
 let InMemoryJobRepository = class InMemoryJobRepository {
+    // Insertion order acts as LRU: most-recently-touched at the end.
     items = new Map();
+    constructor() {
+        this.load();
+    }
     async find(id) {
         return this.items.get(id) ?? null;
     }
@@ -26,15 +46,19 @@ let InMemoryJobRepository = class InMemoryJobRepository {
         item['data'].createdAt = new Date().getTime();
         item.validate();
         this.items.set(item.id, item);
+        this.enforceLimit();
+        this.persist();
     }
     async update(item) {
         if (!item.wasCreated())
             throw new Error('Job was not created');
         item.validate();
-        this.items.set(item.id, item);
+        this.touch(item);
+        this.persist();
     }
     async delete(item) {
         this.items.delete(item.id);
+        this.persist();
     }
     async findPendingForRunFrom(date, limit) {
         const now = date.getTime();
@@ -67,9 +91,57 @@ let InMemoryJobRepository = class InMemoryJobRepository {
         }
         return count;
     }
+    touch(item) {
+        this.items.delete(item.id);
+        this.items.set(item.id, item);
+    }
+    enforceLimit() {
+        while (this.items.size > MAX_JOBS) {
+            const oldestKey = this.items.keys().next().value;
+            if (oldestKey === undefined)
+                break;
+            this.items.delete(oldestKey);
+        }
+    }
+    filePath() {
+        return path.resolve(process.cwd(), JOBS_FILE);
+    }
+    load() {
+        const file = this.filePath();
+        if (!fs.existsSync(file))
+            return;
+        try {
+            const raw = fs.readFileSync(file, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed))
+                return;
+            for (const data of parsed) {
+                if (!data?.id)
+                    continue;
+                const job = new Job(data);
+                this.items.set(job.id, job);
+            }
+            this.enforceLimit();
+        }
+        catch (err) {
+            logger.warn(`Failed to load ${file}:`, err);
+        }
+    }
+    persist() {
+        const file = this.filePath();
+        try {
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            const data = [...this.items.values()].map((j) => j['data']);
+            fs.writeFileSync(file, JSON.stringify(data, null, 2), 'utf-8');
+        }
+        catch (err) {
+            logger.warn(`Failed to persist ${file}:`, err);
+        }
+    }
 };
 InMemoryJobRepository = __decorate([
-    singleton()
+    singleton(),
+    __metadata("design:paramtypes", [])
 ], InMemoryJobRepository);
 
 export { InMemoryJobRepository };

package/dist/src/addon/async/pg/PgCronJobRepository.js

@@ -1,8 +1,7 @@
 import { __decorate, __metadata } from 'tslib';
 import { singleton } from '../../../core/injection/index.js';
 import { CronJob } from '../../../feature/async/CronJob.js';
-import 'short-uuid';
-import '../../../core/error/setupErrorHandlers.js';
+import '../../../feature/repository/MemoryRepositoryAdapter.js';
 import '../../../feature/repository/RepositoryMetadataStore.js';
 import '../../../feature/repository/RepositoryAdapterRegistry.js';
 import '../../../feature/pg/withPgClient.js';

package/dist/src/addon/async/pg/PgJobRepository.js

@@ -1,8 +1,7 @@
 import { __decorate, __metadata } from 'tslib';
 import { Pool } from 'pg';
 import { singleton } from '../../../core/injection/index.js';
-import 'short-uuid';
-import '../../../core/error/setupErrorHandlers.js';
+import '../../../feature/repository/MemoryRepositoryAdapter.js';
 import '../../../feature/repository/RepositoryMetadataStore.js';
 import '../../../feature/repository/RepositoryAdapterRegistry.js';
 import { withPgClient } from '../../../feature/pg/withPgClient.js';

package/dist/src/addon/async/pg/PgTransactionAdapter.js

@@ -1,11 +1,12 @@
 import '../../../core/injection/index.js';
-import 'short-uuid';
-import '../../../core/error/setupErrorHandlers.js';
+import '../../../feature/repository/MemoryRepositoryAdapter.js';
 import '../../../feature/repository/RepositoryMetadataStore.js';
 import '../../../feature/repository/RepositoryAdapterRegistry.js';
 import { withPgClient } from '../../../feature/pg/withPgClient.js';
 import 'debug';
 import '../../../feature/pg/PgLocker.js';
+import 'short-uuid';
+import '../../../core/error/setupErrorHandlers.js';
 import 'node:crypto';
 import '../../../feature/pg/pgStorage.js';
 import { withPgTransaction } from '../../../feature/pg/withPgTransaction.js';

package/dist/src/addon/auth/api-key/PgApiKeyRepository.js

@@ -1,18 +1,18 @@
 import { __decorate, __metadata } from 'tslib';
 import { singleton } from '../../../core/injection/index.js';
-import 'short-uuid';
-import { CustomError } from '../../../core/error/CustomError.js';
-import '../../../core/error/setupErrorHandlers.js';
+import '../../../feature/repository/MemoryRepositoryAdapter.js';
 import '../../../feature/repository/RepositoryMetadataStore.js';
 import '../../../feature/repository/RepositoryAdapterRegistry.js';
 import '../../../feature/pg/withPgClient.js';
 import 'debug';
+import { CustomError } from '../../../core/error/CustomError.js';
 import '../../../feature/pg/PgLocker.js';
 import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
 import 'node:crypto';
 import '../../../feature/pg/pgStorage.js';
 import { Pool } from 'pg';
 import { ApiKey } from './ApiKey.js';
+import '../../../core/error/setupErrorHandlers.js';
 
 let PgApiKeyRepository = class PgApiKeyRepository extends PgCrudRepository {
     constructor(pool) {

package/dist/src/addon/auth/jwt/PgJwtRefreshTokenRepository.js

@@ -2,7 +2,7 @@ import { __decorate, __metadata } from 'tslib';
 import { singleton } from '../../../core/injection/index.js';
 import { CustomError } from '../../../core/error/CustomError.js';
 import '../../../core/error/setupErrorHandlers.js';
-import 'short-uuid';
+import '../../../feature/repository/MemoryRepositoryAdapter.js';
 import '../../../feature/repository/RepositoryMetadataStore.js';
 import '../../../feature/repository/RepositoryAdapterRegistry.js';
 import '../../../feature/pg/withPgClient.js';

package/dist/src/addon/chat-bot/anthropic/AnthropicChatAdapter.js

@@ -167,11 +167,8 @@ let AnthropicChatAdapter = class AnthropicChatAdapter {
             description: tool.description,
             input_schema: {
                 type: 'object',
-                properties: tool.parameters.reduce((prev, param) => ({
-                    ...prev,
-                    [param.name]: { type: param.type, description: param.description },
-                }), {}),
-                required: tool.parameters.map((param) => param.name),
+                properties: tool.parameters.reduce((prev, param) => ({ ...prev, [param.name]: param.schema }), {}),
+                required: tool.parameters.filter((p) => p.required).map((p) => p.name),
             },
         };
     }

package/dist/src/addon/chat-bot/deepseek/DeepSeekChatAdapter.js

@@ -122,14 +122,10 @@ let DeepSeekChatAdapter = class DeepSeekChatAdapter {
                 description: tool.description,
                 parameters: {
                     type: 'object',
-                    properties: tool.parameters.reduce((prev, param) => ({
-                        ...prev,
-                        [param.name]: { type: param.type, description: param.description },
-                    }), {}),
-                    required: tool.parameters.map((param) => param.name),
+                    properties: tool.parameters.reduce((prev, param) => ({ ...prev, [param.name]: param.schema }), {}),
+                    required: tool.parameters.filter((p) => p.required).map((p) => p.name),
                     additionalProperties: false,
                 },
-                strict: true,
             },
         };
     }

package/dist/src/addon/chat-bot/google/GoogleChatAdapter.js

@@ -169,11 +169,8 @@ let GoogleChatAdapter = class GoogleChatAdapter {
             description: tool.description,
             parametersJsonSchema: {
                 type: 'object',
-                properties: tool.parameters.reduce((prev, param) => ({
-                    ...prev,
-                    [param.name]: { type: param.type, description: param.description },
-                }), {}),
-                required: tool.parameters.map((param) => param.name),
+                properties: tool.parameters.reduce((prev, param) => ({ ...prev, [param.name]: param.schema }), {}),
+                required: tool.parameters.filter((p) => p.required).map((p) => p.name),
                 additionalProperties: false,
             },
         };

package/dist/src/addon/chat-bot/in-memory/InMemoryChatRepository.js

@@ -16,7 +16,7 @@ import '../../../core/error/setupErrorHandlers.js';
 
 const CHATS_FILE = '.wabot/in-memory/chats.json';
 const MEMORY_DIR = '.wabot/in-memory';
-const MAX_CHATS = 10;
+const MAX_CHATS = 32;
 const logger = new Logger('wabot:in-memory-chat-repository');
 let InMemoryChatRepository = class InMemoryChatRepository {
     // Ordered least-recently-active first, most-recent last.

package/dist/src/addon/chat-bot/openia/OpenaiChatAdapter.js

@@ -129,20 +129,18 @@ let OpenaiChatAdapter = class OpenaiChatAdapter {
         ];
     }
     mapTool(tool) {
+        const allRequired = tool.parameters.every((p) => p.required);
         return {
             type: 'function',
             name: tool.name,
             description: tool.description,
             parameters: {
                 type: 'object',
-                properties: tool.parameters.reduce((prev, param) => ({
-                    ...prev,
-                    [param.name]: { type: param.type, description: param.description },
-                }), {}),
-                required: tool.parameters.map((param) => param.name),
+                properties: tool.parameters.reduce((prev, param) => ({ ...prev, [param.name]: param.schema }), {}),
+                required: tool.parameters.filter((p) => p.required).map((p) => p.name),
                 additionalProperties: false,
             },
-            strict: true,
+            strict: allRequired,
         };
     }
     mapResponse(response, modelName) {

package/dist/src/addon/chat-bot/openrouter/OpenRouterChatAdapter.js

@@ -146,14 +146,10 @@ let OpenRouterChatAdapter = class OpenRouterChatAdapter {
                 description: tool.description,
                 parameters: {
                     type: 'object',
-                    properties: tool.parameters.reduce((prev, param) => ({
-                        ...prev,
-                        [param.name]: { type: param.type, description: param.description },
-                    }), {}),
-                    required: tool.parameters.map((param) => param.name),
+                    properties: tool.parameters.reduce((prev, param) => ({ ...prev, [param.name]: param.schema }), {}),
+                    required: tool.parameters.filter((p) => p.required).map((p) => p.name),
                     additionalProperties: false,
                 },
-                strict: true,
             },
         };
     }

package/dist/src/addon/chat-bot/pg/PgChatMemory.js

@@ -1,6 +1,5 @@
 import '../../../core/injection/index.js';
-import 'short-uuid';
-import '../../../core/error/setupErrorHandlers.js';
+import '../../../feature/repository/MemoryRepositoryAdapter.js';
 import '../../../feature/repository/RepositoryMetadataStore.js';
 import '../../../feature/repository/RepositoryAdapterRegistry.js';
 import '../../../feature/pg/withPgClient.js';
@@ -17,6 +16,7 @@ import '../../../feature/chat-bot/UnionChatAdapter.js';
 import '../../../feature/chat-bot/metadata/ChatAdapterMetadataStore.js';
 import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import '../../../core/error/setupErrorHandlers.js';
 
 class PgChatMemory extends PgCrudRepository {
     chatId;

package/dist/src/addon/chat-bot/pg/PgChatRepository.js

@@ -2,8 +2,7 @@ import { __decorate, __metadata } from 'tslib';
 import { Pool } from 'pg';
 import { PgChatMemory } from './PgChatMemory.js';
 import { singleton } from '../../../core/injection/index.js';
-import 'short-uuid';
-import '../../../core/error/setupErrorHandlers.js';
+import '../../../feature/repository/MemoryRepositoryAdapter.js';
 import '../../../feature/repository/RepositoryMetadataStore.js';
 import '../../../feature/repository/RepositoryAdapterRegistry.js';
 import '../../../feature/pg/withPgClient.js';
@@ -20,6 +19,7 @@ import '../../../feature/chat-bot/UnionChatAdapter.js';
 import '../../../feature/chat-bot/metadata/ChatAdapterMetadataStore.js';
 import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import '../../../core/error/setupErrorHandlers.js';
 
 let PgChatRepository = class PgChatRepository extends PgCrudRepository {
     constructor(pool) {

package/dist/src/addon/chat-controller/telegram/@telegram.js

@@ -1,4 +1,5 @@
 import { container } from '../../../core/injection/index.js';
+import { resolveConfigReferences } from '../../../core/config/resolver.js';
 import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
 import '../../../feature/chat-controller/ChatResolver.js';
 import '../../../feature/chat-controller/runChatControllers.js';
@@ -7,12 +8,13 @@ import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 
 function telegram(config) {
     return function (target, propertyKey) {
+        const resolved = resolveConfigReferences(config);
         const store = container.resolve(ControllerMetadataStore);
         store.saveChannelMetadata({
             channelConstructor: TelegramChannel,
             functionName: propertyKey.toString(),
             controllerConstructor: target.constructor,
-            channelConfig: new TelegramChannelConfig(config.botToken),
+            channelConfig: new TelegramChannelConfig(resolved.botToken),
         });
     };
 }

package/dist/src/addon/chat-controller/telegram/TelegramChannel.js

@@ -2,6 +2,7 @@ import { __decorate, __metadata } from 'tslib';
 import { Bot } from 'grammy';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 import { injectable } from '../../../core/injection/index.js';
+import { markdownToTelegramHtml } from './markdownToTelegramHtml.js';
 import { telegramChannelName } from './telegramChannelName.js';
 
 var TelegramChannel_1;
@@ -35,7 +36,9 @@ let TelegramChannel = class TelegramChannel {
                 reply: async (replyMessage) => {
                     if (!replyMessage.text)
                         return;
-                    await ctx.reply(replyMessage.text);
+                    await ctx.reply(markdownToTelegramHtml(replyMessage.text), {
+                        parse_mode: 'HTML',
+                    });
                 },
             });
         });

package/dist/src/addon/chat-controller/telegram/markdownToTelegramHtml.js

@@ -0,0 +1,45 @@
+const PH_OPEN = '
';
+const PH_CLOSE = '';
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+function markdownToTelegramHtml(input) {
+    if (!input)
+        return input;
+    const reserved = [];
+    const reserve = (html) => {
+        const token = `${PH_OPEN}${reserved.length}${PH_CLOSE}`;
+        reserved.push(html);
+        return token;
+    };
+    let text = input.replace(/\r\n/g, '\n');
+    text = text.replace(/```(\w+)?\n?([\s\S]*?)```/g, (_, lang, code) => {
+        const escaped = escapeHtml(code.replace(/\n$/, ''));
+        if (lang)
+            return reserve(`<pre><code class="language-${lang}">${escaped}</code></pre>`);
+        return reserve(`<pre>${escaped}</pre>`);
+    });
+    text = text.replace(/`([^`\n]+)`/g, (_, code) => {
+        return reserve(`<code>${escapeHtml(code)}</code>`);
+    });
+    text = text.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_, label, url) => {
+        return reserve(`<a href="${escapeHtml(url)}">${escapeHtml(label)}</a>`);
+    });
+    text = escapeHtml(text);
+    text = text.replace(/^(#{1,6})\s+(.+)$/gm, (_, _hashes, content) => `<b>${content.trim()}</b>`);
+    text = text.replace(/^&gt;\s?(.*)$/gm, '<blockquote>$1</blockquote>');
+    text = text.replace(/<\/blockquote>\n<blockquote>/g, '\n');
+    text = text.replace(/\*\*([^\n*]+?)\*\*/g, '<b>$1</b>');
+    text = text.replace(/__([^\n_]+?)__/g, '<b>$1</b>');
+    text = text.replace(/(^|[\s(>])\*([^\s*][^*\n]*?)\*(?=[\s).,!?:;]|$)/g, '$1<i>$2</i>');
+    text = text.replace(/(^|[\s(>])_([^\s_][^_\n]*?)_(?=[\s).,!?:;]|$)/g, '$1<i>$2</i>');
+    text = text.replace(/~~([^\n~]+?)~~/g, '<s>$1</s>');
+    text = text.replace(/^[ \t]*[-*+]\s+(.+)$/gm, '• $1');
+    text = text.replace(new RegExp(`${PH_OPEN}(\\d+)${PH_CLOSE}`, 'g'), (_, idx) => reserved[Number(idx)]);
+    return text;
+}
+
+export { markdownToTelegramHtml };

package/dist/src/feature/chat-bot/ChatBot.js

@@ -5,11 +5,20 @@ import { MindsetOperator } from '../mindset/MindsetOperator.js';
 import { ChatAdapter } from './ChatAdapter.js';
 import { ChatItem } from './ChatItem.js';
 import { ChatMemory } from './ChatMemory.js';
+import { Logger } from '../../core/logger/Logger.js';
 
+const MAX_CONSECUTIVE_INVALID_ARGS = 2;
+function isInvalidArgsResult(result) {
+    if (!result)
+        return false;
+    return (result.startsWith('{"error":"INVALID_ARGUMENTS"') ||
+        result.startsWith('{"error":"INVALID_JSON_ARGUMENTS"'));
+}
 let ChatBot = class ChatBot {
     memory;
     adapter;
     mindset;
+    logger = new Logger('wabot:chat-bot');
     constructor(memory, adapter, mindset) {
         this.memory = memory;
         this.adapter = adapter;
@@ -21,9 +30,9 @@ let ChatBot = class ChatBot {
             humanMessage: message,
         });
         await this.memory.create(newChatItem);
-        await this.processLoop(callback);
+        await this.processLoop(callback, 0);
     }
-    async processLoop(callback) {
+    async processLoop(callback, invalidArgsCount) {
         const prevItems = await this.memory.findLastItems(16);
         if (prevItems.length === 0) {
             return;
@@ -53,6 +62,12 @@ let ChatBot = class ChatBot {
         for (const newItemData of newItemsData) {
             if (newItemData.type === 'functionCall') {
                 newItemData.functionCall.result = await this.mindset.callFunction(newItemData.functionCall.name, newItemData.functionCall.arguments ?? '{}');
+                if (isInvalidArgsResult(newItemData.functionCall.result)) {
+                    invalidArgsCount++;
+                }
+                else {
+                    invalidArgsCount = 0;
+                }
             }
             else if (newItemData.type === 'botMessage') {
                 newItemData.botMessage.senderName = identity.name;
@@ -63,10 +78,14 @@ let ChatBot = class ChatBot {
                 await callback(newChatItem.botMessage);
             }
         }
+        if (invalidArgsCount >= MAX_CONSECUTIVE_INVALID_ARGS) {
+            this.logger.warn(`Aborting chat loop after ${invalidArgsCount} consecutive invalid-argument function calls`);
+            return;
+        }
         if (newItemsData.length == 0 || newItemsData[newItemsData.length - 1].type === 'botMessage') {
             return;
         }
-        await this.processLoop(callback);
+        await this.processLoop(callback, invalidArgsCount);
     }
 };
 ChatBot = __decorate([

package/dist/src/feature/mindset/MindsetOperator.js

@@ -7,6 +7,8 @@ import '../../core/validation/metadata/ValidationMetadataStore.js';
 import { CustomError, errorToPlainObject } from '../../core/error/CustomError.js';
 import '../../core/error/setupErrorHandlers.js';
 import { Logger } from '../../core/logger/Logger.js';
+import { DescriptionMetadataStore } from '../../core/description/metadata/DescriptionMetadataStore.js';
+import { buildPropertySchema } from './buildParameterSchema.js';
 import { Container } from '../../core/injection/Container.js';
 
 const MODEL_KIND_FALLBACK = {
@@ -16,11 +18,13 @@ const MODEL_KIND_FALLBACK = {
 let MindsetOperator = class MindsetOperator {
     mindset;
     container;
+    descriptionStore;
     logger = new Logger('wabot:mindset-operator');
     metadata;
-    constructor(mindset, container, metadataStore) {
+    constructor(mindset, container, metadataStore, descriptionStore) {
         this.mindset = mindset;
         this.container = container;
+        this.descriptionStore = descriptionStore;
         this.metadata = metadataStore.getMindsetInfo(this.mindset.constructor);
     }
     context() {
@@ -107,38 +111,37 @@ let MindsetOperator = class MindsetOperator {
         return systemPrompt;
     }
     tools() {
+        const deps = {
+            descriptionStore: this.descriptionStore,
+        };
         return this.metadata.modules
             .map((module) => module.functions.map((fn) => {
+            const argsValidatorsInfo = fn.argsValidatorsInfo;
+            const propertyValidators = argsValidatorsInfo?.properties ?? {};
             return {
                 language: module.config?.language ?? 'english',
                 name: fn.name,
                 description: fn.description,
-                parameters: fn.argsDescriptions.map((x) => ({
-                    type: this.paramType(x.typeDescriptor),
-                    name: x.propertyName,
-                    description: this.paramDescription(x.description, x.typeDescriptor),
-                })),
+                parameters: fn.argsDescriptions.map((arg) => {
+                    const propInfo = propertyValidators[arg.propertyName];
+                    const schema = buildPropertySchema(propInfo?.validators ?? [], this.paramDescription(arg.description, arg.typeDescriptor), deps);
+                    return {
+                        name: arg.propertyName,
+                        required: !propInfo?.isOptional,
+                        schema,
+                    };
+                }),
             };
         }))
             .flat();
     }
     paramDescription(rawDescription, rawType) {
-        let description = `
-      ### description (in your main language)
-      ${rawDescription.replaceAll('#', ' ')}
-    `;
+        let description = rawDescription.replaceAll('#', ' ').trim();
         if (rawType === 'date') {
-            description = `${description}
-          ### format: ISO 8681 - YYYY-MM-DDTHH:mm:ssZ
-      `;
+            description = `${description}\nFormat: ISO 8601 - YYYY-MM-DDTHH:mm:ssZ`;
         }
         return description;
     }
-    paramType(rawType) {
-        if (rawType === 'date')
-            return 'string';
-        return rawType;
-    }
     async callFunction(name, params) {
         const fnMetadata = this.metadata.modules
             .map((module) => module.functions)
@@ -151,16 +154,37 @@ let MindsetOperator = class MindsetOperator {
                 message: `Function '${name}' is not registered in mindset tools`,
             });
         }
+        let paramsObj;
         try {
-            let paramsObj = JSON.parse(params);
-            const modelValidationInfo = fnMetadata.argsValidatorsInfo;
-            if (modelValidationInfo) {
-                const validation = validateModel(paramsObj, modelValidationInfo);
-                if (validation.error) {
-                    throw new CustomError({ message: 'IA Params Are invalid', info: validation.error });
-                }
-                paramsObj = validation.value;
+            paramsObj = JSON.parse(params);
+        }
+        catch (parseError) {
+            const aiResponse = JSON.stringify({
+                error: 'INVALID_JSON_ARGUMENTS',
+                message: 'The function call arguments are not valid JSON. Re-issue the call with a valid JSON object.',
+                details: parseError instanceof Error ? parseError.message : String(parseError),
+            });
+            this.logger.error(`Function '${name}' received non-JSON arguments`, { params, parseError });
+            return aiResponse;
+        }
+        const modelValidationInfo = fnMetadata.argsValidatorsInfo;
+        if (modelValidationInfo) {
+            const validation = validateModel(paramsObj, modelValidationInfo);
+            if (validation.error) {
+                const aiResponse = JSON.stringify({
+                    error: 'INVALID_ARGUMENTS',
+                    message: 'The provided arguments did not pass validation. Inspect the errors below and re-issue the call with corrected arguments.',
+                    details: this.flattenValidationError(validation.error),
+                });
+                this.logger.warn(`Function '${name}' received invalid arguments`, {
+                    params,
+                    errors: validation.error,
+                });
+                return aiResponse;
             }
+            paramsObj = validation.value;
+        }
+        try {
             const module = this.container.resolve(fnMetadata.moduleConstructor);
             const response = await module[name](paramsObj);
             if (!response) {
@@ -179,6 +203,41 @@ let MindsetOperator = class MindsetOperator {
             return aiResponse;
         }
     }
+    flattenValidationError(error, path = '') {
+        const out = [];
+        if (!error)
+            return out;
+        if (Array.isArray(error?.items)) {
+            error.items.forEach((itemErrors, idx) => {
+                if (!itemErrors)
+                    return;
+                const itemPath = `${path}[${idx}]`;
+                if (Array.isArray(itemErrors)) {
+                    itemErrors.forEach((ie) => out.push(...this.flattenValidationError(ie, itemPath)));
+                }
+                else {
+                    out.push(...this.flattenValidationError(itemErrors, itemPath));
+                }
+            });
+            if (out.length > 0)
+                return out;
+        }
+        if (error?.properties && typeof error.properties === 'object') {
+            for (const propName in error.properties) {
+                const propErrors = error.properties[propName];
+                const propPath = path ? `${path}.${propName}` : propName;
+                if (Array.isArray(propErrors)) {
+                    propErrors.forEach((pe) => out.push(...this.flattenValidationError(pe, propPath)));
+                }
+            }
+            if (out.length > 0)
+                return out;
+        }
+        if (typeof error.description === 'string') {
+            out.push({ path: path || '(root)', message: error.description });
+        }
+        return out;
+    }
     async functionResponseToString(response) {
         if (response instanceof Response) {
             const contentType = response.headers.get('Content-Type') || '';
@@ -232,7 +291,8 @@ MindsetOperator = __decorate([
     injectable(),
     __metadata("design:paramtypes", [Mindset,
         Container,
-        MindsetMetadataStore])
+        MindsetMetadataStore,
+        DescriptionMetadataStore])
 ], MindsetOperator);
 
 export { MindsetOperator };

package/dist/src/feature/mindset/buildParameterSchema.js

@@ -0,0 +1,155 @@
+import '../../core/injection/index.js';
+import { validateModel } from '../../core/validation/core/validateModel.js';
+import '../../core/validation/metadata/ValidationMetadataStore.js';
+import { validateArray } from '../../core/validation/core/validateArray.js';
+import { validateIsBoolean } from '../../core/validation/validators/is-boolean/validateIsBoolean.js';
+import { validateIsDate } from '../../core/validation/validators/is-date/validateIsDate.js';
+import { validateIsIn } from '../../core/validation/validators/is-in/validateIsIn.js';
+import { validateIsNotEmpty } from '../../core/validation/validators/is-not-empty/validateIsNotEmpty.js';
+import { validateIsNumber } from '../../core/validation/validators/is-number/validateIsNumber.js';
+import { validateIsString } from '../../core/validation/validators/is-string/validateIsString.js';
+import { validateMax } from '../../core/validation/validators/max/validateMax.js';
+import { validateMin } from '../../core/validation/validators/min/validateMin.js';
+import { validateIsRecord } from '../../core/validation/validators/is-record/validateIsRecord.js';
+
+function buildPropertySchema(validators, description, deps) {
+    const schema = { type: 'string' };
+    if (description)
+        schema.description = description;
+    let typeAssigned = false;
+    for (const v of validators) {
+        const { validator, validatorOptions } = v;
+        if (validator === validateIsString) {
+            schema.type = 'string';
+            typeAssigned = true;
+        }
+        else if (validator === validateIsNumber) {
+            schema.type = 'number';
+            typeAssigned = true;
+        }
+        else if (validator === validateIsBoolean) {
+            schema.type = 'boolean';
+            typeAssigned = true;
+        }
+        else if (validator === validateIsDate) {
+            schema.type = 'string';
+            schema.format = 'date-time';
+            typeAssigned = true;
+        }
+        else if (validator === validateArray) {
+            schema.type = 'array';
+            typeAssigned = true;
+            const arrOpts = validatorOptions;
+            if (arrOpts?.minLength != null)
+                schema.minItems = arrOpts.minLength;
+            if (arrOpts?.maxLength != null)
+                schema.maxItems = arrOpts.maxLength;
+            if (arrOpts?.itemsValidator && arrOpts.itemsValidator.length > 0) {
+                const itemValidatorInfos = arrOpts.itemsValidator.map((iv, idx) => ({
+                    propertyName: `__item_${idx}`,
+                    validator: iv.validator,
+                    validatorOptions: iv.options,
+                }));
+                schema.items = buildPropertySchema(itemValidatorInfos, undefined, deps);
+            }
+            else {
+                schema.items = { type: 'string' };
+            }
+        }
+        else if (validator === validateModel) {
+            const modelInfo = validatorOptions;
+            schema.type = 'object';
+            typeAssigned = true;
+            if (modelInfo) {
+                const built = buildModelSchema(modelInfo, deps);
+                schema.properties = built.properties;
+                if (built.required && built.required.length > 0) {
+                    schema.required = built.required;
+                }
+                schema.additionalProperties = false;
+            }
+        }
+        else if (validator === validateIsRecord) {
+            schema.type = 'object';
+            typeAssigned = true;
+            const opts = validatorOptions;
+            if (opts) {
+                schema.additionalProperties = { type: opts.valueType };
+            }
+        }
+        else if (validator === validateIsIn) {
+            const opts = validatorOptions;
+            if (opts) {
+                schema.enum = [...opts.values];
+                if (!typeAssigned) {
+                    const sample = opts.values.find((x) => x != null);
+                    const t = typeof sample;
+                    if (t === 'string' || t === 'number' || t === 'boolean') {
+                        schema.type = t;
+                        typeAssigned = true;
+                    }
+                }
+            }
+        }
+        else if (validator === validateMin) {
+            const opts = validatorOptions;
+            const limit = opts && Number(opts.limit);
+            if (limit != null && !Number.isNaN(limit)) {
+                if (schema.type === 'string') {
+                    schema.minLength = limit;
+                }
+                else if (schema.type === 'array') {
+                    schema.minItems = limit;
+                }
+                else {
+                    schema.minimum = limit;
+                }
+            }
+        }
+        else if (validator === validateMax) {
+            const opts = validatorOptions;
+            const limit = opts && Number(opts.limit);
+            if (limit != null && !Number.isNaN(limit)) {
+                if (schema.type === 'string') {
+                    schema.maxLength = limit;
+                }
+                else if (schema.type === 'array') {
+                    schema.maxItems = limit;
+                }
+                else {
+                    schema.maximum = limit;
+                }
+            }
+        }
+        else if (validator === validateIsNotEmpty) {
+            if (schema.type === 'array') {
+                if (schema.minItems == null || schema.minItems < 1)
+                    schema.minItems = 1;
+            }
+            else {
+                if (schema.minLength == null || schema.minLength < 1)
+                    schema.minLength = 1;
+            }
+        }
+    }
+    return schema;
+}
+function buildModelSchema(modelInfo, deps) {
+    const properties = {};
+    const required = [];
+    const descriptions = deps.descriptionStore.getModelDescriptions(modelInfo.modelConstructor);
+    const descByName = new Map(descriptions.map((d) => [d.propertyName, d]));
+    for (const propertyName in modelInfo.properties) {
+        const propInfo = modelInfo.properties[propertyName];
+        if (!propInfo)
+            continue;
+        const desc = descByName.get(propertyName)?.description;
+        const schema = buildPropertySchema(propInfo.validators ?? [], desc, deps);
+        properties[propertyName] = schema;
+        if (!propInfo.isOptional)
+            required.push(propertyName);
+    }
+    return { properties, required };
+}
+
+export { buildModelSchema, buildPropertySchema };

package/dist/src/feature/pg/@pgExtension.js

@@ -1,6 +1,5 @@
 import { container } from '../../core/injection/index.js';
-import 'short-uuid';
-import '../../core/error/setupErrorHandlers.js';
+import '../repository/MemoryRepositoryAdapter.js';
 import { RepositoryMetadataStore } from '../repository/RepositoryMetadataStore.js';
 import '../repository/RepositoryAdapterRegistry.js';
 import { PgRepositoryBase } from './PgRepositoryBase.js';

package/dist/src/feature/repository/MemoryRepositoryAdapter.js

@@ -1,12 +1,80 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { generate } from 'short-uuid';
 import { CustomError } from '../../core/error/CustomError.js';
 import '../../core/error/setupErrorHandlers.js';
+import { Logger } from '../../core/logger/Logger.js';
 import { evaluateQueryAst } from './evaluateQueryAst.js';
 
+const DEFAULT_PERSIST_DIR = '.wabot/in-memory';
+const DEFAULT_MAX_ITEMS = 32;
+const logger = new Logger('wabot:memory-repository-adapter');
 function cloneEntity(config, item) {
     const data = JSON.parse(JSON.stringify(item['data']));
     return new config.constructor(data);
 }
+class MemoryStore {
+    config;
+    persistOptions;
+    // Insertion order acts as LRU: most-recently-touched at the end.
+    items = new Map();
+    constructor(config, persistOptions) {
+        this.config = config;
+        this.persistOptions = persistOptions;
+        this.load();
+    }
+    touch(item) {
+        this.items.delete(item.id);
+        this.items.set(item.id, item);
+    }
+    enforceLimit() {
+        while (this.items.size > this.persistOptions.maxItems) {
+            const oldest = this.items.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.items.delete(oldest);
+        }
+    }
+    persist() {
+        if (!this.persistOptions.enabled)
+            return;
+        const file = this.filePath();
+        try {
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            const data = [...this.items.values()].map((i) => i['data']);
+            fs.writeFileSync(file, JSON.stringify(data, null, 2), 'utf-8');
+        }
+        catch (err) {
+            logger.warn(`Failed to persist ${file}:`, err);
+        }
+    }
+    load() {
+        if (!this.persistOptions.enabled)
+            return;
+        const file = this.filePath();
+        if (!fs.existsSync(file))
+            return;
+        try {
+            const raw = fs.readFileSync(file, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed))
+                return;
+            for (const data of parsed) {
+                if (!data?.id)
+                    continue;
+                const item = new this.config.constructor(data);
+                this.items.set(data.id, item);
+            }
+            this.enforceLimit();
+        }
+        catch (err) {
+            logger.warn(`Failed to load ${file}:`, err);
+        }
+    }
+    filePath() {
+        return path.resolve(process.cwd(), this.persistOptions.dir, `${this.config.table}.json`);
+    }
+}
 class MemoryRepositoryExtension {
     items;
     config;
@@ -19,12 +87,15 @@ class MemoryRepositoryExtension {
     }
 }
 class MemoryRepositoryRuntime {
-    items;
+    store;
     config;
-    constructor(items, config) {
-        this.items = items;
+    constructor(store, config) {
+        this.store = store;
         this.config = config;
     }
+    get items() {
+        return this.store.items;
+    }
     async find(id) {
         const item = this.items.get(id);
         return item ? cloneEntity(this.config, item) : null;
@@ -58,17 +129,22 @@ class MemoryRepositoryRuntime {
         item['data'].id = generate();
         item['data'].createdAt = new Date().getTime();
         item.validate();
-        this.items.set(item.id, cloneEntity(this.config, item));
+        const stored = cloneEntity(this.config, item);
+        this.store.touch(stored);
+        this.store.enforceLimit();
+        this.store.persist();
     }
     async update(item) {
         item.validate();
         if (!this.items.has(item.id)) {
             throw new Error(`Update failed: no affected rows`);
         }
-        this.items.set(item.id, cloneEntity(this.config, item));
+        this.store.touch(cloneEntity(this.config, item));
+        this.store.persist();
     }
     async delete(item) {
         this.items.delete(item.id);
+        this.store.persist();
     }
     async runQuery(ast, args) {
         const result = evaluateQueryAst(this.items.values(), ast, args);
@@ -85,16 +161,26 @@ class MemoryRepositoryRuntime {
         for (const item of matched) {
             this.items.delete(item.id);
         }
+        if (matched.length > 0)
+            this.store.persist();
     }
 }
 const MEMORY_ADAPTER_ID = Symbol('wabot:memory-adapter');
 class MemoryRepositoryAdapter {
     id = MEMORY_ADAPTER_ID;
     stores = new Map();
+    persistOptions;
+    constructor(options = {}) {
+        this.persistOptions = {
+            enabled: options.persist ?? true,
+            dir: options.dir ?? DEFAULT_PERSIST_DIR,
+            maxItems: options.maxItems ?? DEFAULT_MAX_ITEMS,
+        };
+    }
     getStore(config) {
         let store = this.stores.get(config);
         if (!store) {
-            store = new Map();
+            store = new MemoryStore(config, this.persistOptions);
             this.stores.set(config, store);
         }
         return store;
@@ -103,7 +189,7 @@ class MemoryRepositoryAdapter {
         return new MemoryRepositoryRuntime(this.getStore(config), config);
     }
     buildExtension(config, ExtensionCtor) {
-        return new ExtensionCtor(this.getStore(config), config);
+        return new ExtensionCtor(this.getStore(config).items, config);
     }
 }
 

package/dist/src/index.d.ts

@@ -867,10 +867,26 @@ declare class MindsetMetadataStore {
     };
 }
 
+interface IMindsetParameterSchema {
+    type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object';
+    description?: string;
+    enum?: (string | number | boolean | null)[];
+    format?: string;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    minItems?: number;
+    maxItems?: number;
+    items?: IMindsetParameterSchema;
+    properties?: Record<string, IMindsetParameterSchema>;
+    required?: string[];
+    additionalProperties?: boolean | IMindsetParameterSchema;
+}
 interface IMindsetToolParameter {
-    type: string;
     name: string;
-    description: string;
+    required: boolean;
+    schema: IMindsetParameterSchema;
 }
 
 interface IMindsetTool {
@@ -883,9 +899,10 @@ interface IMindsetTool {
 declare class MindsetOperator implements IMindset {
     private mindset;
     private container;
+    private descriptionStore;
     private logger;
     private metadata;
-    constructor(mindset: Mindset, container: Container, metadataStore: MindsetMetadataStore);
+    constructor(mindset: Mindset, container: Container, metadataStore: MindsetMetadataStore, descriptionStore: DescriptionMetadataStore);
     context(): Promise<string>;
     identity(): Promise<IMindsetIdentity>;
     skills(): Promise<string>;
@@ -898,8 +915,8 @@ declare class MindsetOperator implements IMindset {
     systemPrompt(): Promise<string>;
     tools(): IMindsetTool[];
     protected paramDescription(rawDescription: string, rawType: string): string;
-    protected paramType(rawType: string): string;
     callFunction(name: string, params: string): Promise<string>;
+    private flattenValidationError;
     functionResponseToString(response: any): Promise<string>;
     functionErrorToString(error: any): Promise<string>;
 }
@@ -1028,9 +1045,10 @@ declare class ChatBot implements IChatBot {
     private memory;
     private adapter;
     private mindset;
+    private logger;
     constructor(memory: ChatMemory, adapter: ChatAdapter, mindset: MindsetOperator);
     sendMessage(message: IChatMessage, callback: (message: IChatMessage) => Promise<void>): Promise<void>;
-    protected processLoop(callback: (message: IChatMessage) => Promise<void>): Promise<void>;
+    protected processLoop(callback: (message: IChatMessage) => Promise<void>, invalidArgsCount: number): Promise<void>;
 }
 
 interface IChatRepository {
@@ -1373,6 +1391,11 @@ interface IRepositoryAdapter {
     buildExtension?<E>(config: IRepositoryConfig<any>, ExtensionCtor: IConstructor<E>): E;
 }
 
+interface IMemoryRepositoryAdapterOptions {
+    persist?: boolean;
+    dir?: string;
+    maxItems?: number;
+}
 declare class MemoryRepositoryExtension<P extends Entity<IEntityData>> {
     protected readonly items: Map<string, P>;
     protected readonly config: IRepositoryConfig<P>;
@@ -1383,6 +1406,8 @@ declare const MEMORY_ADAPTER_ID: unique symbol;
 declare class MemoryRepositoryAdapter implements IRepositoryAdapter {
     readonly id: symbol;
     private stores;
+    private readonly persistOptions;
+    constructor(options?: IMemoryRepositoryAdapterOptions);
     private getStore;
     build<P extends Entity<IEntityData>>(config: IRepositoryConfig<P>): IRepositoryRuntime<P>;
     buildExtension<E>(config: IRepositoryConfig<any>, ExtensionCtor: IConstructor<E>): E;
@@ -1645,6 +1670,7 @@ declare class PgTransactionAdapter implements ITransactionAdapter {
 
 declare class InMemoryJobRepository implements IJobRepository {
     private items;
+    constructor();
     find(id: string): Promise<Job | null>;
     findOrThrow(id: string): Promise<Job>;
     findByIds(ids: string[]): Promise<Job[]>;
@@ -1655,15 +1681,26 @@ declare class InMemoryJobRepository implements IJobRepository {
     findPendingForRunFrom(date: Date, limit: number): Promise<Job[]>;
     findRunningJobs(): Promise<Job[]>;
     countRunningByCommand(commandName: string): Promise<number>;
+    private touch;
+    private enforceLimit;
+    private filePath;
+    private load;
+    private persist;
 }
 
 declare class InMemoryCronJobRepository implements ICronJobRepository {
     private items;
+    constructor();
     create(cronJob: CronJob): Promise<void>;
     findDue(date?: Date): Promise<CronJob[]>;
     findOrThrow(id: string): Promise<CronJob>;
     update(cronJob: CronJob): Promise<void>;
     findByName(name: string): Promise<CronJob | null>;
+    private touch;
+    private enforceLimit;
+    private filePath;
+    private load;
+    private persist;
 }
 
 declare function apiKeyHandshakeGuard(): (target: IConstructor<any>) => void;
@@ -2138,9 +2175,9 @@ declare class SocketChannel implements IChatChannel {
 }
 
 interface ITelegramChannelConfig {
-    botToken: string;
+    botToken: string | ConfigReference<string>;
 }
-declare class TelegramChannelConfig implements ITelegramChannelConfig {
+declare class TelegramChannelConfig {
     botToken: string;
     constructor(botToken: string);
 }
@@ -2168,6 +2205,8 @@ declare class TelegramChannel implements IChatChannel {
     disconnect(): void;
 }
 
+declare function markdownToTelegramHtml(input: string): string;
+
 interface IWhatsAppCloudTemplateResponse {
     data: IWhatsAppCloudTemplate[];
     paging: IWhatsAppCloudApiPaging;
@@ -2485,4 +2524,4 @@ declare function HtmlModule(options: IHtmlModuleOptions): {
     new (): {};
 };
 
-export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, AsyncMetadataStore, Auth, Chat, ChatAdapter, ChatAdapterMetadataStore, ChatAdapterRegistry, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatOperator, ChatRepository, ChatResolver, type ClientMap, CmdChannel, CmdChannelConfig, CmdChannelServer, type CmdClientMessage, type CmdServerMessage, type ConfigReference, type ConfigReferenceType, ConfigResolver, Container, ControllerMetadataStore, CronJob, CronJobRepository, CrudRepository, CustomError, DeepSeekChatAdapter, DescriptionMetadataStore, EXPRESS_REQ, EXPRESS_RES, Entity, Env, type ErrorSeverity, ExpressProvider, GoogleChatAdapter, type GoogleChatAdapterV2Options, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IBuiltQuery, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterDecoratorConfig, type IChatAdapterMetadata, type IChatAdapterNextItemsReq, type IChatAdapterNextItemsRes, type IChatAssociation, type IChatBot, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatItem, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatMessageDocument, type IChatMessageFile, type IChatMessageImage, type IChatMessagesPrivateFile, type IChatMessagesPublicFile, type IChatRepository, type IChatType, type ICmdChannelEntry, type ICmdChannelHandlers, type ICmdChannelMessage, type ICmdReceivedMessage, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICronConfig, type ICronHandler, type ICronJobData, type ICronJobRepository, type ICrudRepository, type ICustomErrorData, type IDescriptionMetadata, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IErrorHandlersConfig, type IErrorMonitor, type IErrorMonitorContext, type IExtractChatMessageTextOptions, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type ILockKey, type ILocker, type ILockerKey, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetConfig, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModelKind, type IMindsetModelRef, type IMindsetModels, type IMindsetModuleConfig, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IPersistentData, type IPgRepositoryConfig, type IProjectRunnerConfig, type IPropertyValidatorInfo, type IQueryAst, type IQueryCondition, type IQueryMethodMetadata, type IQueryOrderBy, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRepositoryAdapter, type IRepositoryConfig, type IRepositoryRuntime, type IRestControllerConfig, type IRestControllerMetadata, type IScanProjectFilesOptions, type IScheduleAt, type IScheduleDelay, type ISendWhatsAppMessageReq, type ISendWhatsAppTemplateReq, type ISocketChannelConfig, type ISocketChannelMessage, type ISocketChannelReceivedMessage, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type ISocketReceivedMessage, type IStorableData, type ITelegramChannelConfig, type ITelegramChannelMessage, type ITelegramReceivedMessage, type ITransactionAdapter, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateIsRecordOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWasenderChannelConfig, type IWasenderChannelMessageListener, type IWasenderDeviceListMetadata, type IWasenderEvent, type IWasenderMessageContent, type IWasenderMessageContextInfo, type IWasenderMessageKey, type IWasenderMessageReceivedData, type IWasenderMessageReceivedEvent, type IWasenderQrUpdatedEvent, type IWasenderReceivedMessage, type IWhatsAppCloudContact, type IWhatsAppCloudMessage, type IWhatsAppCloudMessageMetadata, type IWhatsAppCloudTemplate, type IWhatsAppCloudTemplateComponent, type IWhatsAppCloudTemplateResponse, type IWhatsAppCloudWebhookPayload, type IWhatsAppSender, type IWhatsAppTemplateData, type IWhatsAppTemplateParameter, type IchatControllerConfig, InMemoryChatMemory, InMemoryChatRepository, InMemoryCronJobRepository, InMemoryJobRepository, InMemoryLockKey, InMemoryLocker, Job, JobRepository, JobRunner, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Locker, Logger, MEMORY_ADAPTER_ID, Mapper, MemoryRepositoryAdapter, MemoryRepositoryExtension, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenRouterChatAdapter, OpenaiChatAdapter, PG_ADAPTER_ID, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCronJobRepository, PgCrudRepository, PgJobRepository, PgJsonRepositoryAdapter, PgJwtRefreshTokenRepository, PgLockKey, PgLocker, PgRepositoryBase, PgRepositoryBase as PgRepositoryExtension, PgTransactionAdapter, ProjectRunner, type QueryConnector, type QueryOperator, type QueryPrefix, Random, RemoteApiKeyRepository, RepositoryAdapterRegistry, RepositoryMetadataStore, type ResolvedConfig, RestControllerMetadataStore, RestRequest, SocketChannel, SocketChannelConfig, SocketChannelMessageFile, SocketChannelReceivedMessage, SocketControllerMetadataStore, SocketServerConfig, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, TransactionMetadataStore, UnionChatAdapter, ValidationMetadataStore, WabotChatAdapter, WasenderChannel, WasenderChannelConfig, WasenderReceiver, WasenderSender, WasenderWebhookController, WhatsAppApiSender, WhatsAppReceiverByCloudApi, WhatsAppSender, apiKeyGuard, apiKeyHandshakeGuard, bool, boolArr, buildQuerySql, chatAdapter, chatBot, chatController, chatItemTypeOptions, cmd, cmdChannelName, cmdChannelSocketPath, command, commandHandler, container, cronHandler, description, errorToPlainObject, evaluateQueryAst, extractChatMessageText, extractNumberFromWasenderMessageKey, getClientMap, getPgClient, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isChatMessageEmpty, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isRecord, isRetryableError, isString, jwtGuard, jwtHandshakeGuard, max, memExtension, middleware, min, mindset, mindsetModule, modelInfo, num, numArr, obj, onDelete, onGet, onPost, onPut, onSocketEvent, parseQueryMethodName, pgExtension, pgStorage, query, queryExtension, readJsonFromFile, repository, resolveConfigReferences, restController, run, runChatAdapters, runChatControllers, runCmdClient, runCommandHandlers, runCronHandlers, runRestControllers, runSocketControllers, safeJsonParse, scanProjectFiles, scoped, setupErrorHandlers, singleton, socket, socketChannelName, socketController, stopCommandHandlers, stopCronHandlers, str, strArr, telegram, telegramChannelName, transaction, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsRecord, validateIsString, validateMax, validateMin, validateModel, wasender, wasenderChannelName, withPgClient, withPgTransaction, writeJsonToFile };
+export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, AsyncMetadataStore, Auth, Chat, ChatAdapter, ChatAdapterMetadataStore, ChatAdapterRegistry, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatOperator, ChatRepository, ChatResolver, type ClientMap, CmdChannel, CmdChannelConfig, CmdChannelServer, type CmdClientMessage, type CmdServerMessage, type ConfigReference, type ConfigReferenceType, ConfigResolver, Container, ControllerMetadataStore, CronJob, CronJobRepository, CrudRepository, CustomError, DeepSeekChatAdapter, DescriptionMetadataStore, EXPRESS_REQ, EXPRESS_RES, Entity, Env, type ErrorSeverity, ExpressProvider, GoogleChatAdapter, type GoogleChatAdapterV2Options, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IBuiltQuery, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterDecoratorConfig, type IChatAdapterMetadata, type IChatAdapterNextItemsReq, type IChatAdapterNextItemsRes, type IChatAssociation, type IChatBot, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatItem, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatMessageDocument, type IChatMessageFile, type IChatMessageImage, type IChatMessagesPrivateFile, type IChatMessagesPublicFile, type IChatRepository, type IChatType, type ICmdChannelEntry, type ICmdChannelHandlers, type ICmdChannelMessage, type ICmdReceivedMessage, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICronConfig, type ICronHandler, type ICronJobData, type ICronJobRepository, type ICrudRepository, type ICustomErrorData, type IDescriptionMetadata, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IErrorHandlersConfig, type IErrorMonitor, type IErrorMonitorContext, type IExtractChatMessageTextOptions, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type ILockKey, type ILocker, type ILockerKey, type IMemoryRepositoryAdapterOptions, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetConfig, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModelKind, type IMindsetModelRef, type IMindsetModels, type IMindsetModuleConfig, type IMindsetModuleMetadata, type IMindsetParameterSchema, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IPersistentData, type IPgRepositoryConfig, type IProjectRunnerConfig, type IPropertyValidatorInfo, type IQueryAst, type IQueryCondition, type IQueryMethodMetadata, type IQueryOrderBy, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRepositoryAdapter, type IRepositoryConfig, type IRepositoryRuntime, type IRestControllerConfig, type IRestControllerMetadata, type IScanProjectFilesOptions, type IScheduleAt, type IScheduleDelay, type ISendWhatsAppMessageReq, type ISendWhatsAppTemplateReq, type ISocketChannelConfig, type ISocketChannelMessage, type ISocketChannelReceivedMessage, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type ISocketReceivedMessage, type IStorableData, type ITelegramChannelConfig, type ITelegramChannelMessage, type ITelegramReceivedMessage, type ITransactionAdapter, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateIsRecordOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWasenderChannelConfig, type IWasenderChannelMessageListener, type IWasenderDeviceListMetadata, type IWasenderEvent, type IWasenderMessageContent, type IWasenderMessageContextInfo, type IWasenderMessageKey, type IWasenderMessageReceivedData, type IWasenderMessageReceivedEvent, type IWasenderQrUpdatedEvent, type IWasenderReceivedMessage, type IWhatsAppCloudContact, type IWhatsAppCloudMessage, type IWhatsAppCloudMessageMetadata, type IWhatsAppCloudTemplate, type IWhatsAppCloudTemplateComponent, type IWhatsAppCloudTemplateResponse, type IWhatsAppCloudWebhookPayload, type IWhatsAppSender, type IWhatsAppTemplateData, type IWhatsAppTemplateParameter, type IchatControllerConfig, InMemoryChatMemory, InMemoryChatRepository, InMemoryCronJobRepository, InMemoryJobRepository, InMemoryLockKey, InMemoryLocker, Job, JobRepository, JobRunner, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Locker, Logger, MEMORY_ADAPTER_ID, Mapper, MemoryRepositoryAdapter, MemoryRepositoryExtension, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenRouterChatAdapter, OpenaiChatAdapter, PG_ADAPTER_ID, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCronJobRepository, PgCrudRepository, PgJobRepository, PgJsonRepositoryAdapter, PgJwtRefreshTokenRepository, PgLockKey, PgLocker, PgRepositoryBase, PgRepositoryBase as PgRepositoryExtension, PgTransactionAdapter, ProjectRunner, type QueryConnector, type QueryOperator, type QueryPrefix, Random, RemoteApiKeyRepository, RepositoryAdapterRegistry, RepositoryMetadataStore, type ResolvedConfig, RestControllerMetadataStore, RestRequest, SocketChannel, SocketChannelConfig, SocketChannelMessageFile, SocketChannelReceivedMessage, SocketControllerMetadataStore, SocketServerConfig, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, TransactionMetadataStore, UnionChatAdapter, ValidationMetadataStore, WabotChatAdapter, WasenderChannel, WasenderChannelConfig, WasenderReceiver, WasenderSender, WasenderWebhookController, WhatsAppApiSender, WhatsAppReceiverByCloudApi, WhatsAppSender, apiKeyGuard, apiKeyHandshakeGuard, bool, boolArr, buildQuerySql, chatAdapter, chatBot, chatController, chatItemTypeOptions, cmd, cmdChannelName, cmdChannelSocketPath, command, commandHandler, container, cronHandler, description, errorToPlainObject, evaluateQueryAst, extractChatMessageText, extractNumberFromWasenderMessageKey, getClientMap, getPgClient, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isChatMessageEmpty, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isRecord, isRetryableError, isString, jwtGuard, jwtHandshakeGuard, markdownToTelegramHtml, max, memExtension, middleware, min, mindset, mindsetModule, modelInfo, num, numArr, obj, onDelete, onGet, onPost, onPut, onSocketEvent, parseQueryMethodName, pgExtension, pgStorage, query, queryExtension, readJsonFromFile, repository, resolveConfigReferences, restController, run, runChatAdapters, runChatControllers, runCmdClient, runCommandHandlers, runCronHandlers, runRestControllers, runSocketControllers, safeJsonParse, scanProjectFiles, scoped, setupErrorHandlers, singleton, socket, socketChannelName, socketController, stopCommandHandlers, stopCronHandlers, str, strArr, telegram, telegramChannelName, transaction, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsRecord, validateIsString, validateMax, validateMin, validateModel, wasender, wasenderChannelName, withPgClient, withPgTransaction, writeJsonToFile };

package/dist/src/index.js

@@ -177,6 +177,7 @@ export { telegram } from './addon/chat-controller/telegram/@telegram.js';
 export { TelegramChannelConfig } from './addon/chat-controller/telegram/TelegramChannelConfig.js';
 export { TelegramChannel } from './addon/chat-controller/telegram/TelegramChannel.js';
 export { telegramChannelName } from './addon/chat-controller/telegram/telegramChannelName.js';
+export { markdownToTelegramHtml } from './addon/chat-controller/telegram/markdownToTelegramHtml.js';
 export { WhatsAppReceiverByCloudApi } from './addon/chat-controller/whatsapp/cloud-api/WhatsAppReceiverByCloudApi.js';
 export { WhatsAppApiSender } from './addon/chat-controller/whatsapp/cloud-api/WhatsAppApiSender.js';
 export { wasender } from './addon/chat-controller/whatsapp/wasender/@wasender.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.9.17",
+  "version": "0.9.19",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",