@wabot-dev/framework 0.5.15 → 0.7.0

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

@@ -7,8 +7,16 @@ import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 import { safeJsonParse } from '../../../feature/chat-bot/safeJsonParse.js';
 import { extractChatMessageText } from '../../../feature/chat-bot/extractChatMessageText.js';
+import { isChatMessageEmpty } from '../../../feature/chat-bot/isChatMessageEmpty.js';
 import { Anthropic } from '@anthropic-ai/sdk';
 
+const ANTHROPIC_SUPPORTED_IMAGE_MIME_TYPES = [
+    'image/png',
+    'image/jpeg',
+    'image/gif',
+    'image/webp',
+];
+const ANTHROPIC_SUPPORTED_DOCUMENT_MIME_TYPES = ['application/pdf', 'text/plain'];
 let AnthropicChatAdapter = class AnthropicChatAdapter {
     env;
     anthropic;
@@ -50,10 +58,59 @@ let AnthropicChatAdapter = class AnthropicChatAdapter {
         return messages;
     }
     mapHumanMessage(item) {
-        if (!item.text) {
+        if (isChatMessageEmpty(item)) {
             throw new Error('User message content is empty');
         }
-        return { role: 'user', content: item.text };
+        const blocks = [];
+        blocks.push({
+            type: 'text',
+            text: extractChatMessageText(item, {
+                supportedImageMimeTypes: ANTHROPIC_SUPPORTED_IMAGE_MIME_TYPES,
+                supportedDocumentMimeTypes: ANTHROPIC_SUPPORTED_DOCUMENT_MIME_TYPES,
+            }),
+        });
+        if (item.images) {
+            for (const image of item.images) {
+                if (!ANTHROPIC_SUPPORTED_IMAGE_MIME_TYPES.includes(image.mimeType))
+                    continue;
+                blocks.push({ type: 'image', source: this.toAnthropicImageSource(image) });
+            }
+        }
+        if (item.documents) {
+            for (const doc of item.documents) {
+                if (!ANTHROPIC_SUPPORTED_DOCUMENT_MIME_TYPES.includes(doc.mimeType))
+                    continue;
+                blocks.push({ type: 'document', source: this.toAnthropicDocumentSource(doc) });
+            }
+        }
+        return { role: 'user', content: blocks };
+    }
+    toAnthropicImageSource(image) {
+        if (image.publicUrl) {
+            return { type: 'url', url: image.publicUrl };
+        }
+        return {
+            type: 'base64',
+            media_type: image.mimeType,
+            data: stripDataUrlPrefix(image.base64Url),
+        };
+    }
+    toAnthropicDocumentSource(doc) {
+        if (doc.publicUrl) {
+            return { type: 'url', url: doc.publicUrl };
+        }
+        if (doc.mimeType === 'text/plain') {
+            return {
+                type: 'text',
+                media_type: 'text/plain',
+                data: Buffer.from(stripDataUrlPrefix(doc.base64Url), 'base64').toString('utf-8'),
+            };
+        }
+        return {
+            type: 'base64',
+            media_type: 'application/pdf',
+            data: stripDataUrlPrefix(doc.base64Url),
+        };
     }
     mapBotMessage(item) {
         if (!item.text) {
@@ -134,5 +191,9 @@ AnthropicChatAdapter = __decorate([
     singleton(),
     __metadata("design:paramtypes", [Env])
 ], AnthropicChatAdapter);
+function stripDataUrlPrefix(dataUrl) {
+    const commaIndex = dataUrl.indexOf(',');
+    return commaIndex >= 0 && dataUrl.startsWith('data:') ? dataUrl.slice(commaIndex + 1) : dataUrl;
+}
 
 export { AnthropicChatAdapter };

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

@@ -5,6 +5,7 @@ import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 import '../../../core/error/setupErrorHandlers.js';
 import { extractChatMessageText } from '../../../feature/chat-bot/extractChatMessageText.js';
+import { isChatMessageEmpty } from '../../../feature/chat-bot/isChatMessageEmpty.js';
 import { OpenAI } from 'openai';
 
 class DeepSeekChatAdapter {
@@ -55,10 +56,16 @@ class DeepSeekChatAdapter {
         return deepSeekInput;
     }
     mapHumanMessage(item) {
-        if (!item.text) {
+        if (isChatMessageEmpty(item)) {
             throw new Error('User message content is empty');
         }
-        return { role: 'user', content: extractChatMessageText(item) };
+        return {
+            role: 'user',
+            content: extractChatMessageText(item, {
+                supportedImageMimeTypes: [],
+                supportedDocumentMimeTypes: [],
+            }),
+        };
     }
     mapBotMessage(item) {
         if (!item.text) {

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

@@ -8,8 +8,26 @@ import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 import { safeJsonParse } from '../../../feature/chat-bot/safeJsonParse.js';
 import { extractChatMessageText } from '../../../feature/chat-bot/extractChatMessageText.js';
+import { isChatMessageEmpty } from '../../../feature/chat-bot/isChatMessageEmpty.js';
 import { GoogleGenAI } from '@google/genai';
 
+const GOOGLE_SUPPORTED_IMAGE_MIME_TYPES = [
+    'image/png',
+    'image/jpeg',
+    'image/webp',
+    'image/heic',
+    'image/heif',
+];
+const GOOGLE_SUPPORTED_DOCUMENT_MIME_TYPES = [
+    'application/pdf',
+    'text/plain',
+    'text/csv',
+    'text/html',
+    'text/markdown',
+    'text/xml',
+    'text/rtf',
+    'application/json',
+];
 let GoogleChatAdapter = class GoogleChatAdapter {
     ai;
     logger = new Logger('wabot:google-chat-adapter-v2');
@@ -46,10 +64,39 @@ let GoogleChatAdapter = class GoogleChatAdapter {
         return contents;
     }
     mapHumanMessage(item) {
-        if (!item.text) {
+        if (isChatMessageEmpty(item)) {
             throw new Error('User message content is empty');
         }
-        return { role: 'user', parts: [{ text: item.text }] };
+        const parts = [];
+        parts.push({
+            text: extractChatMessageText(item, {
+                supportedImageMimeTypes: GOOGLE_SUPPORTED_IMAGE_MIME_TYPES,
+                supportedDocumentMimeTypes: GOOGLE_SUPPORTED_DOCUMENT_MIME_TYPES,
+            }),
+        });
+        if (item.images) {
+            for (const image of item.images) {
+                if (!GOOGLE_SUPPORTED_IMAGE_MIME_TYPES.includes(image.mimeType))
+                    continue;
+                parts.push(this.toGoogleFilePart(image));
+            }
+        }
+        if (item.documents) {
+            for (const doc of item.documents) {
+                if (!GOOGLE_SUPPORTED_DOCUMENT_MIME_TYPES.includes(doc.mimeType))
+                    continue;
+                parts.push(this.toGoogleFilePart(doc));
+            }
+        }
+        return { role: 'user', parts };
+    }
+    toGoogleFilePart(file) {
+        if (file.publicUrl) {
+            return { fileData: { fileUri: file.publicUrl, mimeType: file.mimeType } };
+        }
+        return {
+            inlineData: { data: stripDataUrlPrefix(file.base64Url), mimeType: file.mimeType },
+        };
     }
     mapBotMessage(item) {
         if (!item.text) {
@@ -144,5 +191,9 @@ GoogleChatAdapter = __decorate([
     singleton(),
     __metadata("design:paramtypes", [Env])
 ], GoogleChatAdapter);
+function stripDataUrlPrefix(dataUrl) {
+    const commaIndex = dataUrl.indexOf(',');
+    return commaIndex >= 0 && dataUrl.startsWith('data:') ? dataUrl.slice(commaIndex + 1) : dataUrl;
+}
 
 export { GoogleChatAdapter };

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

@@ -5,9 +5,17 @@ import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 import '../../../core/error/setupErrorHandlers.js';
 import { extractChatMessageText } from '../../../feature/chat-bot/extractChatMessageText.js';
+import { isChatMessageEmpty } from '../../../feature/chat-bot/isChatMessageEmpty.js';
 import { Logger } from '../../../core/logger/Logger.js';
 import { OpenAI } from 'openai';
 
+const OPENAI_SUPPORTED_IMAGE_MIME_TYPES = [
+    'image/png',
+    'image/jpeg',
+    'image/webp',
+    'image/gif',
+];
+const OPENAI_SUPPORTED_DOCUMENT_MIME_TYPES = ['application/pdf'];
 let OpenaiChatAdapter = class OpenaiChatAdapter {
     openai = new OpenAI();
     logger = new Logger('wabot:openai-chat-adapter');
@@ -41,11 +49,21 @@ let OpenaiChatAdapter = class OpenaiChatAdapter {
         return openIaInput;
     }
     mapConectionMessage(item) {
+        if (isChatMessageEmpty(item)) {
+            throw new Error('User message content is empty');
+        }
         const content = [];
-        if (item.text)
-            content.push({ type: 'input_text', text: extractChatMessageText(item) });
+        content.push({
+            type: 'input_text',
+            text: extractChatMessageText(item, {
+                supportedImageMimeTypes: OPENAI_SUPPORTED_IMAGE_MIME_TYPES,
+                supportedDocumentMimeTypes: OPENAI_SUPPORTED_DOCUMENT_MIME_TYPES,
+            }),
+        });
         if (item.images) {
             for (const image of item.images) {
+                if (!OPENAI_SUPPORTED_IMAGE_MIME_TYPES.includes(image.mimeType))
+                    continue;
                 content.push({
                     type: 'input_image',
                     image_url: image.publicUrl ?? image.base64Url,
@@ -53,8 +71,21 @@ let OpenaiChatAdapter = class OpenaiChatAdapter {
                 });
             }
         }
-        if (content.length === 0) {
-            throw new Error('message content is empty');
+        if (item.documents) {
+            for (const doc of item.documents) {
+                if (!OPENAI_SUPPORTED_DOCUMENT_MIME_TYPES.includes(doc.mimeType))
+                    continue;
+                if (doc.publicUrl) {
+                    content.push({ type: 'input_file', file_url: doc.publicUrl });
+                }
+                else {
+                    content.push({
+                        type: 'input_file',
+                        file_data: doc.base64Url,
+                        filename: doc.name ?? `${doc.id}.pdf`,
+                    });
+                }
+            }
         }
         return { role: 'user', content };
     }

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

@@ -7,8 +7,16 @@ import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 import '../../../core/error/setupErrorHandlers.js';
 import { extractChatMessageText } from '../../../feature/chat-bot/extractChatMessageText.js';
+import { isChatMessageEmpty } from '../../../feature/chat-bot/isChatMessageEmpty.js';
 import { OpenRouter } from '@openrouter/sdk';
 
+const OPENROUTER_SUPPORTED_IMAGE_MIME_TYPES = [
+    'image/png',
+    'image/jpeg',
+    'image/webp',
+    'image/gif',
+];
+const OPENROUTER_SUPPORTED_DOCUMENT_MIME_TYPES = ['application/pdf'];
 let OpenRouterChatAdapter = class OpenRouterChatAdapter {
     env;
     openRouter;
@@ -51,19 +59,31 @@ let OpenRouterChatAdapter = class OpenRouterChatAdapter {
         return messages;
     }
     mapHumanMessage(item) {
+        if (isChatMessageEmpty(item)) {
+            throw new Error('User message content is empty');
+        }
         const contentParts = [];
-        if (item.text)
-            contentParts.push(extractChatMessageText(item));
+        contentParts.push(extractChatMessageText(item, {
+            supportedImageMimeTypes: OPENROUTER_SUPPORTED_IMAGE_MIME_TYPES,
+            supportedDocumentMimeTypes: OPENROUTER_SUPPORTED_DOCUMENT_MIME_TYPES,
+        }));
         if (item.images) {
             for (const image of item.images) {
+                if (!OPENROUTER_SUPPORTED_IMAGE_MIME_TYPES.includes(image.mimeType))
+                    continue;
                 const imageUrl = image.publicUrl ?? image.base64Url;
-                if (imageUrl) {
+                if (imageUrl)
                     contentParts.push(imageUrl);
-                }
             }
         }
-        if (contentParts.length === 0) {
-            throw new Error('User message content is empty');
+        if (item.documents) {
+            for (const doc of item.documents) {
+                if (!OPENROUTER_SUPPORTED_DOCUMENT_MIME_TYPES.includes(doc.mimeType))
+                    continue;
+                const docUrl = doc.publicUrl ?? doc.base64Url;
+                if (docUrl)
+                    contentParts.push(docUrl);
+            }
         }
         return { role: 'user', content: contentParts.join('\n') };
     }

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

@@ -10,6 +10,7 @@ import '../../../feature/pg/withPgClient.js';
 import '../../../feature/pg/pgStorage.js';
 import { Chat } from '../../../feature/chat-bot/Chat.js';
 import '../../../feature/chat-bot/ChatBot.js';
+import { ChatOperator } from '../../../feature/chat-bot/ChatOperator.js';
 import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 import '../../../core/error/setupErrorHandlers.js';
@@ -25,7 +26,7 @@ let PgChatRepository = class PgChatRepository extends PgCrudRepository {
     async findByConnection(query) {
         const sql = `
       SELECT ${this.columns}
-      FROM ${this.table} 
+      FROM ${this.table}
       WHERE data->'connections' @> $1::jsonb
       LIMIT 1
     `;
@@ -35,6 +36,13 @@ let PgChatRepository = class PgChatRepository extends PgCrudRepository {
     async findMemory(chatId) {
         return new PgChatMemory(this.pool, chatId);
     }
+    async findOperator(chatId) {
+        const chat = await this.find(chatId);
+        if (!chat)
+            return null;
+        const memory = new PgChatMemory(this.pool, chatId);
+        return new ChatOperator(chat, memory, this);
+    }
 };
 PgChatRepository = __decorate([
     singleton(),

package/dist/src/addon/chat-bot/ram/RamChatRepository.js

@@ -2,6 +2,10 @@ import { __decorate } from 'tslib';
 import { v4 } from 'uuid';
 import { RamChatMemory } from './RamChatMemory.js';
 import { singleton } from '../../../core/injection/index.js';
+import '../../../feature/chat-bot/ChatBot.js';
+import { ChatOperator } from '../../../feature/chat-bot/ChatOperator.js';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import '../../../core/error/setupErrorHandlers.js';
 
 let RamChatRepository = class RamChatRepository {
     items = [];
@@ -36,6 +40,15 @@ let RamChatRepository = class RamChatRepository {
         }
         return Promise.resolve(memory.memory);
     }
+    async findOperator(chatId) {
+        const chat = this.items.find((item) => item.id === chatId) ?? null;
+        if (!chat)
+            return null;
+        const memory = this.getMemory(chatId);
+        if (!memory)
+            return null;
+        return new ChatOperator(chat, memory.memory, this);
+    }
     getMemory(chatId) {
         return this.memories.find((r) => r.chatId === chatId) ?? null;
     }

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

@@ -33,20 +33,40 @@ class Chat extends Entity {
         }
         this.data.connections.push(connection);
     }
-    hasAssociation(type, id) {
-        return this.data.associations?.some((a) => a.type === type && a.id === id) ?? false;
+    removeConnection(connection) {
+        const index = this.data.connections.findIndex((c) => c.channelName === connection.channelName && c.id === connection.id);
+        if (index === -1) {
+            throw new Error('Connection does not exist');
+        }
+        this.data.connections.splice(index, 1);
+    }
+    hasAssociation(association) {
+        return this.data.associations?.some((a) => a.type === association.type && a.id === association.id) ?? false;
+    }
+    hasAssociations(type) {
+        return this.data.associations?.some((a) => a.type === type) ?? false;
     }
     getAssociationsByType(type) {
         return this.data.associations?.filter((a) => a.type === type) ?? [];
     }
     addAssociation(association) {
-        if (this.hasAssociation(association.type, association.id)) {
+        if (this.hasAssociation(association)) {
             throw new Error('Association already exists');
         }
         if (!this.data.associations)
             this.data.associations = [];
         this.data.associations.push(association);
     }
+    removeAssociation(association) {
+        if (!this.data.associations) {
+            throw new Error('Association does not exist');
+        }
+        const index = this.data.associations.findIndex((a) => a.type === association.type && a.id === association.id);
+        if (index === -1) {
+            throw new Error('Association does not exist');
+        }
+        this.data.associations.splice(index, 1);
+    }
     validatePrivateChat() {
         if (this.data.connections.length < 1) {
             throw new Error('PRIVATE chat should have one or more connections');

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

@@ -0,0 +1,54 @@
+import { ChatItem } from './ChatItem.js';
+
+class ChatOperator {
+    chat;
+    memory;
+    repository;
+    constructor(chat, memory, repository) {
+        this.chat = chat;
+        this.memory = memory;
+        this.repository = repository;
+    }
+    async saveHumanMessage(message) {
+        const item = new ChatItem({ type: 'humanMessage', humanMessage: message });
+        await this.memory.create(item);
+        return item;
+    }
+    async saveBotMessage(message) {
+        const item = new ChatItem({ type: 'botMessage', botMessage: message });
+        await this.memory.create(item);
+        return item;
+    }
+    getConnections() {
+        return this.chat.connections;
+    }
+    async addConnection(connection) {
+        this.chat.addConnection(connection);
+        await this.repository.update(this.chat);
+    }
+    async removeConnection(connection) {
+        this.chat.removeConnection(connection);
+        await this.repository.update(this.chat);
+    }
+    hasAssociations(type) {
+        return this.chat.hasAssociations(type);
+    }
+    hasAssociation(association) {
+        return this.chat.hasAssociation(association);
+    }
+    findAssociations(type) {
+        if (type === undefined)
+            return this.chat.associations;
+        return this.chat.getAssociationsByType(type);
+    }
+    async addAssociation(association) {
+        this.chat.addAssociation(association);
+        await this.repository.update(this.chat);
+    }
+    async removeAssociation(association) {
+        this.chat.removeAssociation(association);
+        await this.repository.update(this.chat);
+    }
+}
+
+export { ChatOperator };

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

@@ -11,6 +11,9 @@ class ChatRepository {
     findMemory(chatId) {
         throw new Error('Method not implemented.');
     }
+    findOperator(chatId) {
+        throw new Error('Method not implemented.');
+    }
 }
 
 export { ChatRepository };

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

@@ -1,13 +1,29 @@
-function extractChatMessageText(message) {
+function extractChatMessageText(message, options = {}) {
     const messageData = {
         senderId: message.senderId,
         senderName: message.senderName,
         text: message.text,
         object: message.object,
         metadata: message.metadata,
-        images: message.images?.map((x) => ({ id: x.id, name: x.name })),
+        images: message.images?.map((x) => ({
+            id: x.id,
+            name: x.name,
+            mimeType: x.mimeType,
+            notAnalyzed: isAnalyzed(x.mimeType, options.supportedImageMimeTypes) ? undefined : true,
+        })),
+        documents: message.documents?.map((x) => ({
+            id: x.id,
+            name: x.name,
+            mimeType: x.mimeType,
+            notAnalyzed: isAnalyzed(x.mimeType, options.supportedDocumentMimeTypes) ? undefined : true,
+        })),
     };
     return JSON.stringify(messageData);
 }
+function isAnalyzed(mimeType, supported) {
+    if (supported === undefined)
+        return true;
+    return supported.includes(mimeType);
+}
 
 export { extractChatMessageText };

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

@@ -0,0 +1,5 @@
+function isChatMessageEmpty(message) {
+    return (!message.text && !message.images?.length && !message.documents?.length && !message.object);
+}
+
+export { isChatMessageEmpty };

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

@@ -4,13 +4,15 @@ import { Mindset } from './IMindset.js';
 import { MindsetMetadataStore } from './metadata/MindsetMetadataStore.js';
 import { validateModel } from '../../core/validation/core/validateModel.js';
 import '../../core/validation/metadata/ValidationMetadataStore.js';
-import { CustomError } from '../../core/error/CustomError.js';
+import { CustomError, errorToPlainObject } from '../../core/error/CustomError.js';
 import '../../core/error/setupErrorHandlers.js';
+import { Logger } from '../../core/logger/Logger.js';
 import { Container } from '../../core/injection/Container.js';
 
 let MindsetOperator = class MindsetOperator {
     mindset;
     container;
+    logger = new Logger('wabot:mindset-operator');
     metadata;
     constructor(mindset, container, metadataStore) {
         this.mindset = mindset;
@@ -139,7 +141,14 @@ let MindsetOperator = class MindsetOperator {
             return await this.functionResponseToString(response);
         }
         catch (error) {
-            return await this.functionErrorToString(error);
+            const aiResponse = await this.functionErrorToString(error);
+            if (error instanceof Error) {
+                this.logger.error(`Function '${name}' threw an exception`, error, { aiResponse });
+            }
+            else {
+                this.logger.error(`Function '${name}' threw a non-Error value`, { error, aiResponse });
+            }
+            return aiResponse;
         }
     }
     async functionResponseToString(response) {
@@ -181,6 +190,10 @@ let MindsetOperator = class MindsetOperator {
                 body: typeof data === 'object' ? data : { message: data?.toString?.() || 'Unknown error' },
             });
         }
+        if (error instanceof Error) {
+            const { stack: _stack, ...plain } = errorToPlainObject(error);
+            return JSON.stringify(plain);
+        }
         if (error?.message) {
             return error.message;
         }

package/dist/src/feature/pg/PgCrudRepository.js

@@ -1,4 +1,4 @@
-import * as shortUUID from 'short-uuid';
+import { generate } from 'short-uuid';
 import { PgRepositoryBase } from './PgRepositoryBase.js';
 import { CustomError } from '../../core/error/CustomError.js';
 import '../../core/error/setupErrorHandlers.js';
@@ -54,7 +54,7 @@ class PgCrudRepository extends PgRepositoryBase {
         if (item.wasCreated()) {
             throw new Error('Item already created');
         }
-        item['data'].id = shortUUID.default.generate();
+        item['data'].id = generate();
         item['data'].createdAt = new Date().getTime();
         item.validate();
         const sql = `

package/dist/src/index.d.ts

@@ -678,12 +678,15 @@ declare class Chat extends Entity<IChatData> {
         id: string;
     } | null;
     addConnection(connection: IChatConnection): void;
-    hasAssociation(type: string, id: string): boolean;
+    removeConnection(connection: IChatConnection): void;
+    hasAssociation(association: IChatAssociation): boolean;
+    hasAssociations(type: string): boolean;
     getAssociationsByType(type: string): {
         type: string;
         id: string;
     }[];
     addAssociation(association: IChatAssociation): void;
+    removeAssociation(association: IChatAssociation): void;
     private validatePrivateChat;
     private validateGroupChat;
     validate(): void;
@@ -805,6 +808,7 @@ interface IMindsetTool {
 declare class MindsetOperator implements IMindset {
     private mindset;
     private container;
+    private logger;
     private metadata;
     constructor(mindset: Mindset, container: Container, metadataStore: MindsetMetadataStore);
     context(): Promise<string>;
@@ -822,27 +826,32 @@ declare class MindsetOperator implements IMindset {
     functionErrorToString(error: any): Promise<string>;
 }
 
-interface IChatMessagesPublicImage {
+interface IChatMessagesPublicFile {
     name?: string;
     publicUrl: string;
     base64Url?: undefined;
     mimeType: string;
     id: string;
 }
-interface IChatMessagesPrivateImage {
+interface IChatMessagesPrivateFile {
     name?: string;
     publicUrl?: undefined;
     base64Url: string;
     mimeType: string;
     id: string;
 }
-type IChatMessageImage = IChatMessagesPrivateImage | IChatMessagesPublicImage;
+type IChatMessageFile = IChatMessagesPrivateFile | IChatMessagesPublicFile;
+
+type IChatMessageDocument = IChatMessageFile;
+
+type IChatMessageImage = IChatMessageFile;
 
 interface IChatMessage {
     senderId?: string;
     senderName?: string;
     text?: string;
     images?: IChatMessageImage[];
+    documents?: IChatMessageDocument[];
     object?: object;
     metadata?: Record<string, string>;
 }
@@ -938,6 +947,24 @@ interface IChatRepository {
     update(chat: Chat): Promise<void>;
     findByConnection(query: IChatConnection): Promise<Chat | null>;
     findMemory(chatId: string): Promise<IChatMemory | null>;
+    findOperator(chatId: string): Promise<ChatOperator | null>;
+}
+
+declare class ChatOperator {
+    private chat;
+    private memory;
+    private repository;
+    constructor(chat: Chat, memory: IChatMemory, repository: IChatRepository);
+    saveHumanMessage(message: IChatMessage): Promise<ChatItem>;
+    saveBotMessage(message: IChatMessage): Promise<ChatItem>;
+    getConnections(): IChatConnection[];
+    addConnection(connection: IChatConnection): Promise<void>;
+    removeConnection(connection: IChatConnection): Promise<void>;
+    hasAssociations(type: string): boolean;
+    hasAssociation(association: IChatAssociation): boolean;
+    findAssociations(type?: string): IChatAssociation[];
+    addAssociation(association: IChatAssociation): Promise<void>;
+    removeAssociation(association: IChatAssociation): Promise<void>;
 }
 
 declare class ChatRepository implements IChatRepository {
@@ -945,6 +972,7 @@ declare class ChatRepository implements IChatRepository {
     update(chat: Chat): Promise<void>;
     findByConnection(query: IChatConnection): Promise<Chat | null>;
     findMemory(chatId: string): Promise<IChatMemory | null>;
+    findOperator(chatId: string): Promise<ChatOperator | null>;
 }
 
 declare function chatBot(mindset: IConstructor<IMindset>): (target: object, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
@@ -963,7 +991,13 @@ declare class ChatBotMetadataStore {
 
 declare function safeJsonParse<T = unknown>(json: string | undefined | null, context?: string): T;
 
-declare function extractChatMessageText(message: IChatMessage): string;
+interface IExtractChatMessageTextOptions {
+    supportedImageMimeTypes?: readonly string[];
+    supportedDocumentMimeTypes?: readonly string[];
+}
+declare function extractChatMessageText(message: IChatMessage, options?: IExtractChatMessageTextOptions): string;
+
+declare function isChatMessageEmpty(message: IChatMessage): boolean;
 
 interface IchatControllerConfig {
 }
@@ -1513,6 +1547,8 @@ declare class AnthropicChatAdapter implements IChatAdapter {
     nextItems(req: IChatAdapterNextItemsReq): Promise<IChatAdapterNextItemsRes>;
     private mapChatItems;
     private mapHumanMessage;
+    private toAnthropicImageSource;
+    private toAnthropicDocumentSource;
     private mapBotMessage;
     private mapFunctionCall;
     private mapTool;
@@ -1542,6 +1578,7 @@ declare class GoogleChatAdapter implements IChatAdapter {
     nextItems(req: IChatAdapterNextItemsReq): Promise<IChatAdapterNextItemsRes>;
     private mapChatItems;
     private mapHumanMessage;
+    private toGoogleFilePart;
     private mapBotMessage;
     private mapFunctionCall;
     private mapTool;
@@ -1578,6 +1615,7 @@ declare class PgChatRepository extends PgCrudRepository<Chat> implements IChatRe
     constructor(pool: Pool);
     findByConnection(query: IChatConnection): Promise<Chat | null>;
     findMemory(chatId: string): Promise<IChatMemory | null>;
+    findOperator(chatId: string): Promise<ChatOperator | null>;
 }
 
 declare class PgChatMemory extends PgCrudRepository<ChatItem> implements IChatMemory {
@@ -1600,6 +1638,7 @@ declare class RamChatRepository implements IChatRepository {
     create(chat: Chat): Promise<void>;
     findByConnection(query: IChatConnection): Promise<Chat | null>;
     findMemory(chatId: string): Promise<IChatMemory | null>;
+    findOperator(chatId: string): Promise<ChatOperator | null>;
     private getMemory;
 }
 
@@ -2178,4 +2217,4 @@ declare function HtmlModule(options: IHtmlModuleOptions): {
     new (): {};
 };
 
-export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, AsyncMetadataStore, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, type ClientMap, CmdChannel, Container, ControllerMetadataStore, CronJob, CronJobRepository, CustomError, DeepSeekChatAdapter, DescriptionMetadataStore, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, type ErrorSeverity, ExpressProvider, GoogleChatAdapter, type GoogleChatAdapterV2Options, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, 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 IChatRepository, type IChatType, type ICmdChannelMessage, type ICmdReceivedMessage, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICronConfig, type ICronJobData, type ICrudRepository, type ICustomErrorData, type IDescriptionMetadata, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IErrorHandlersConfig, type IErrorMonitor, type IErrorMonitorContext, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IGetWhatsAppTemplateRequest, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type ILockKey, type ILocker, type ILockerKey, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetConfig, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IPersistentData, type IPgRepositoryConfig, type IPropertyValidatorInfo, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRestControllerConfig, type IRestControllerMetadata, type IScheduleAt, type IScheduleDelay, type ISendByWasenderRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, 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 IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateIsRecordOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWasenderChannelMessageListener, type IWasenderDeviceListMetadata, type IWasenderEvent, type IWasenderMessageContent, type IWasenderMessageContextInfo, type IWasenderMessageKey, type IWasenderMessageReceivedData, type IWasenderMessageReceivedEvent, type IWasenderQrUpdatedEvent, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppByWasenderChannelConfig, type IWhatsAppByWasenderReceivedMessage, type IWhatsAppChannelMessage, type IWhatsAppCloudContact, type IWhatsAppCloudMessage, type IWhatsAppCloudMessageMetadata, type IWhatsAppCloudTemplate, type IWhatsAppCloudTemplateComponent, type IWhatsAppCloudTemplateMessage, type IWhatsAppCloudTemplateParameter, type IWhatsAppCloudTemplateResponse, type IWhatsAppCloudWebhookPayload, type IWhatsAppData, type IWhatsAppMessageListener, type IWhatsAppProxyListenMessageEventData, type IWhatsAppProxyListenMessageEventReq, type IWhatsAppProxyMessage, type IWhatsAppProxyMessageContent, type IWhatsAppProxyMessageEventReq, type IWhatsAppProxySendMessageEventReq, type IWhatsAppReceivedMessage, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsappChannelConfig, type IchatControllerConfig, Job, JobRepository, JobRunner, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Locker, Logger, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenRouterChatAdapter, OpenaiChatAdapter, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCronJobRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgLockKey, PgLocker, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, RestRequest, SocketChannel, SocketChannelConfig, SocketChannelReceivedMessage, SocketControllerMetadataStore, SocketServerConfig, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT, WabotChatAdapter, WasenderWebhookController, WhatsApp, WhatsAppByWasenderChannel, WhatsAppByWasenderChannelConfig, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByCloudApi, WhatsAppReceiverByWabotProxy, WhatsAppReceiverByWasender, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByWabotProxy, WhatsAppSenderByWasender, WhatsAppWabotProxyConnection, WhatsappChannelConfig, apiKeyGuard, apiKeyHandshakeGuard, chatBot, chatController, chatItemTypeOptions, cmd, cmdChannelName, command, commandHandler, container, cron, description, errorToPlainObject, extractChatMessageText, extractNumberFromWasenderMessageKey, getClientMap, getPgClient, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isRecord, isString, jwtGuard, jwtHandshakeGuard, max, middleware, min, mindset, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, onSocketEvent, pgStorage, readJsonFromFile, restController, runChatControllers, runCommandHandlers, runCronHandlers, runRestControllers, runSocketControllers, safeJsonParse, scoped, setupErrorHandlers, singleton, socket, socketChannelName, socketController, stopCommandHandlers, stopCronHandlers, telegram, telegramChannelName, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsRecord, validateIsString, validateMax, validateMin, validateModel, whatsApp, whatsAppByWasender, whatsAppByWasenderChannelName, whatsAppChannelName, withPgClient, withPgTransaction, writeJsonToFile };
+export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, AsyncMetadataStore, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatOperator, ChatRepository, ChatResolver, type ClientMap, CmdChannel, Container, ControllerMetadataStore, CronJob, CronJobRepository, CustomError, DeepSeekChatAdapter, DescriptionMetadataStore, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, type ErrorSeverity, ExpressProvider, GoogleChatAdapter, type GoogleChatAdapterV2Options, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, 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 ICmdChannelMessage, type ICmdReceivedMessage, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICronConfig, type ICronJobData, 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 IGetWhatsAppTemplateRequest, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type ILockKey, type ILocker, type ILockerKey, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetConfig, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IPersistentData, type IPgRepositoryConfig, type IPropertyValidatorInfo, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRestControllerConfig, type IRestControllerMetadata, type IScheduleAt, type IScheduleDelay, type ISendByWasenderRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, 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 IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateIsRecordOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWasenderChannelMessageListener, type IWasenderDeviceListMetadata, type IWasenderEvent, type IWasenderMessageContent, type IWasenderMessageContextInfo, type IWasenderMessageKey, type IWasenderMessageReceivedData, type IWasenderMessageReceivedEvent, type IWasenderQrUpdatedEvent, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppByWasenderChannelConfig, type IWhatsAppByWasenderReceivedMessage, type IWhatsAppChannelMessage, type IWhatsAppCloudContact, type IWhatsAppCloudMessage, type IWhatsAppCloudMessageMetadata, type IWhatsAppCloudTemplate, type IWhatsAppCloudTemplateComponent, type IWhatsAppCloudTemplateMessage, type IWhatsAppCloudTemplateParameter, type IWhatsAppCloudTemplateResponse, type IWhatsAppCloudWebhookPayload, type IWhatsAppData, type IWhatsAppMessageListener, type IWhatsAppProxyListenMessageEventData, type IWhatsAppProxyListenMessageEventReq, type IWhatsAppProxyMessage, type IWhatsAppProxyMessageContent, type IWhatsAppProxyMessageEventReq, type IWhatsAppProxySendMessageEventReq, type IWhatsAppReceivedMessage, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsappChannelConfig, type IchatControllerConfig, Job, JobRepository, JobRunner, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Locker, Logger, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenRouterChatAdapter, OpenaiChatAdapter, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCronJobRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgLockKey, PgLocker, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, RestRequest, SocketChannel, SocketChannelConfig, SocketChannelReceivedMessage, SocketControllerMetadataStore, SocketServerConfig, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT, WabotChatAdapter, WasenderWebhookController, WhatsApp, WhatsAppByWasenderChannel, WhatsAppByWasenderChannelConfig, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByCloudApi, WhatsAppReceiverByWabotProxy, WhatsAppReceiverByWasender, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByWabotProxy, WhatsAppSenderByWasender, WhatsAppWabotProxyConnection, WhatsappChannelConfig, apiKeyGuard, apiKeyHandshakeGuard, chatBot, chatController, chatItemTypeOptions, cmd, cmdChannelName, command, commandHandler, container, cron, description, errorToPlainObject, extractChatMessageText, extractNumberFromWasenderMessageKey, getClientMap, getPgClient, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isChatMessageEmpty, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isRecord, isString, jwtGuard, jwtHandshakeGuard, max, middleware, min, mindset, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, onSocketEvent, pgStorage, readJsonFromFile, restController, runChatControllers, runCommandHandlers, runCronHandlers, runRestControllers, runSocketControllers, safeJsonParse, scoped, setupErrorHandlers, singleton, socket, socketChannelName, socketController, stopCommandHandlers, stopCronHandlers, telegram, telegramChannelName, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsRecord, validateIsString, validateMax, validateMin, validateModel, whatsApp, whatsAppByWasender, whatsAppByWasenderChannelName, whatsAppChannelName, withPgClient, withPgTransaction, writeJsonToFile };

package/dist/src/index.js

@@ -57,12 +57,14 @@ export { ChatAdapter } from './feature/chat-bot/ChatAdapter.js';
 export { ChatBot } from './feature/chat-bot/ChatBot.js';
 export { ChatItem } from './feature/chat-bot/ChatItem.js';
 export { ChatMemory } from './feature/chat-bot/ChatMemory.js';
+export { ChatOperator } from './feature/chat-bot/ChatOperator.js';
 export { ChatRepository } from './feature/chat-bot/ChatRepository.js';
 export { chatItemTypeOptions } from './feature/chat-bot/IChatItem.js';
 export { chatBot } from './feature/chat-bot/metadata/@chatBot.js';
 export { ChatBotMetadataStore } from './feature/chat-bot/metadata/ChatBotMetadataStore.js';
 export { safeJsonParse } from './feature/chat-bot/safeJsonParse.js';
 export { extractChatMessageText } from './feature/chat-bot/extractChatMessageText.js';
+export { isChatMessageEmpty } from './feature/chat-bot/isChatMessageEmpty.js';
 export { chatController } from './feature/chat-controller/metadata/controller/@chatController.js';
 export { ControllerMetadataStore } from './feature/chat-controller/metadata/ControllerMetadataStore.js';
 export { ChatResolver } from './feature/chat-controller/ChatResolver.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.5.15",
+  "version": "0.7.0",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",
@@ -35,11 +35,12 @@
     "prettier": "^3.5.3",
     "rollup": "^4.60.0",
     "tsup": "^8.4.0",
-    "typescript": "5.8.3"
+    "typescript": "^6.0.3"
   },
   "peerDependencies": {
     "@anthropic-ai/sdk": "^0.60.0",
     "@google/genai": "^1.16.0",
+    "@openrouter/sdk": "^0.12.2",
     "@types/big.js": "^6.2.2",
     "@types/debug": "^4.1.12",
     "@types/express": "^5.0.1",
@@ -60,13 +61,12 @@
     "openai": "^6.10.0",
     "pg": "^8.15.6",
     "reflect-metadata": "^0.2.2",
-    "short-uuid": "^5.2.0",
+    "short-uuid": "^6.0.3",
     "socket.io": "^4.8.1",
     "socket.io-client": "^4.8.1",
     "tslib": "^2.8.1",
     "tsyringe": "^4.9.1",
-    "uuid": "^11.1.0",
-    "wasenderapi": "^0.1.5",
-    "@openrouter/sdk": "^0.12.2"
+    "uuid": "^14.0.0",
+    "wasenderapi": "^0.1.5"
   }
 }