@wabot-dev/framework 0.2.0-beta.9 → 0.2.1-beta.1

package/dist/src/addon/auth/api-key/@apiKeyGuard.js

@@ -6,6 +6,7 @@ import '../../../core/validation/metadata/ValidationMetadataStore.js';
 import '../../../feature/express/ExpressProvider.js';
 import 'express';
 import 'path';
+import '../../../feature/rest-controller/RestRequest.js';
 import { ApiKeyGuardMiddleware } from './ApiKeyGuardMiddleware.js';
 
 function apiKeyGuard() {

package/dist/src/addon/auth/jwt/@jwtGuard.js

@@ -6,6 +6,7 @@ import '../../../core/validation/metadata/ValidationMetadataStore.js';
 import '../../../feature/express/ExpressProvider.js';
 import 'express';
 import 'path';
+import '../../../feature/rest-controller/RestRequest.js';
 import { JwtGuardMiddleware } from './JwtGuardMiddleware.js';
 
 function jwtGuard() {

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

@@ -13,7 +13,7 @@ let AnthropicChatAdapter = class AnthropicChatAdapter {
         const apiKey = this.env.requireString('ANTHROPIC_API_KEY');
         this.anthropic = new Anthropic({ apiKey });
     }
-    async nextItem(req) {
+    async nextItems(req) {
         const tools = req.tools.map((x) => this.mapTool(x));
         const messages = this.mapChatItems(req.prevItems);
         const request = {
@@ -96,24 +96,6 @@ let AnthropicChatAdapter = class AnthropicChatAdapter {
         };
     }
     mapResponse(response) {
-        let chatItem;
-        const content = response.content[0];
-        if (content.type === 'text') {
-            chatItem = { type: 'botMessage', botMessage: { text: content.text } };
-        }
-        else if (content.type === 'tool_use') {
-            chatItem = {
-                type: 'functionCall',
-                functionCall: {
-                    id: content.id,
-                    name: content.name,
-                    arguments: JSON.stringify(content.input),
-                },
-            };
-        }
-        else {
-            throw new Error('Not supported Claude Response');
-        }
         let usage;
         if (response.usage) {
             usage = {
@@ -124,7 +106,23 @@ let AnthropicChatAdapter = class AnthropicChatAdapter {
         else {
             throw new Error('Unable to found usage info');
         }
-        return { chatItem, usage };
+        const nextItems = [];
+        for (const content of response.content) {
+            if (content.type === 'text' && content.text) {
+                nextItems.push({ type: 'botMessage', botMessage: { text: content.text } });
+            }
+            else if (content.type === 'tool_use') {
+                nextItems.push({
+                    type: 'functionCall',
+                    functionCall: {
+                        id: content.id,
+                        name: content.name,
+                        arguments: JSON.stringify(content.input),
+                    },
+                });
+            }
+        }
+        return { usage, nextItems };
     }
 };
 AnthropicChatAdapter = __decorate([

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

@@ -18,7 +18,7 @@ class DeepSeekChatAdapter {
             baseURL,
         });
     }
-    async nextItem(req) {
+    async nextItems(req) {
         const deepSeekInput = [];
         deepSeekInput.push({ role: 'system', content: req.systemPrompt });
         deepSeekInput.push(...this.mapChatItems(req.prevItems));
@@ -130,7 +130,7 @@ class DeepSeekChatAdapter {
         else {
             throw new Error('Unable to found usage info');
         }
-        return { chatItem, usage };
+        return { nextItems: [chatItem], usage };
     }
 }
 

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

@@ -2,122 +2,133 @@ import { __decorate, __metadata } from 'tslib';
 import { Env } from '../../../core/env/Env.js';
 import { singleton } from '../../../core/injection/index.js';
 import { Logger } from '../../../core/logger/Logger.js';
-import OpenAI from 'openai';
+import { Random } from '../../../core/random/Random.js';
+import { GoogleGenAI } from '@google/genai';
 
 let GoogleChatAdapter = class GoogleChatAdapter {
-    env;
-    openai;
-    logger = new Logger('wabot:google-chat-adapter');
+    ai;
+    logger = new Logger('wabot:google-chat-adapter-v2');
     constructor(env) {
-        this.env = env;
-        const apiKey = this.env.requireString('GOOGLE_API_KEY');
-        this.openai = new OpenAI({
-            apiKey,
-            baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
-        });
+        this.ai = new GoogleGenAI({ apiKey: env.requireString('GOOGLE_API_KEY') });
     }
-    async nextItem(req) {
-        const messages = [];
-        messages.push({ role: 'system', content: req.systemPrompt });
-        messages.push(...this.mapChatItems(req.prevItems));
-        const tools = req.tools.map((x) => this.mapTool(x));
-        const request = {
+    async nextItems(req) {
+        const contents = [];
+        contents.push({ role: 'user', parts: [{ text: req.systemPrompt }] });
+        contents.push(...this.mapChatItems(req.prevItems));
+        const functionDeclarations = req.tools.map((x) => this.mapTool(x));
+        const response = await this.ai.models.generateContent({
             model: req.model,
-            messages,
-            tools,
-        };
-        const response = await this.openai.chat.completions.create(request);
+            contents,
+            config: { tools: [{ functionDeclarations }] },
+        });
         return this.mapResponse(response);
     }
     mapChatItems(chatItems) {
-        const messages = [];
+        const contents = [];
         for (const chatItem of chatItems) {
             switch (chatItem.type) {
                 case 'humanMessage':
-                    messages.push(this.mapHumanMessage(chatItem.humanMessage));
+                    contents.push(this.mapHumanMessage(chatItem.humanMessage));
                     break;
                 case 'botMessage':
-                    messages.push(this.mapBotMessage(chatItem.botMessage));
+                    contents.push(this.mapBotMessage(chatItem.botMessage));
                     break;
                 case 'functionCall':
-                    messages.push(...this.mapFunctionCall(chatItem.functionCall));
+                    contents.push(...this.mapFunctionCall(chatItem.functionCall));
                     break;
             }
         }
-        return messages;
+        return contents;
     }
     mapHumanMessage(item) {
         if (!item.text) {
             throw new Error('User message content is empty');
         }
-        return { role: 'user', content: item.text };
+        return { role: 'user', parts: [{ text: item.text }] };
     }
     mapBotMessage(item) {
         if (!item.text) {
             throw new Error('Bot message content is empty');
         }
-        return { role: 'assistant', content: item.text };
+        return { role: 'model', parts: [{ text: item.text }] };
     }
     mapFunctionCall(item) {
         return [
+            {
+                role: 'model',
+                parts: [
+                    {
+                        functionCall: {
+                            id: item.id,
+                            name: item.name,
+                            args: JSON.parse(item.arguments ?? '{}'),
+                        },
+                    },
+                ],
+            },
             {
                 role: 'function',
-                name: item.id,
-                content: item.result ?? 'No result',
+                parts: [
+                    {
+                        functionResponse: {
+                            id: item.id,
+                            name: item.name,
+                            response: { output: item.result ?? '' },
+                        },
+                    },
+                ],
             },
         ];
     }
     mapTool(tool) {
         return {
-            type: 'function',
-            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),
-                    additionalProperties: false,
-                }
+            name: tool.name,
+            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),
+                additionalProperties: false,
             },
         };
     }
     mapResponse(response) {
-        let chatItem;
-        const { tool_calls: responseFunctionCall, content: responseText } = response.choices?.[0]?.message ?? {};
-        if (responseText) {
-            chatItem = { type: 'botMessage', botMessage: { text: responseText } };
+        if (!response.candidates || !response.candidates.length) {
+            throw new Error('No candidates in response');
         }
-        else if (responseFunctionCall && responseFunctionCall[0]?.type === 'function') {
-            chatItem = {
-                type: 'functionCall',
-                functionCall: {
-                    id: responseFunctionCall[0].id,
-                    name: responseFunctionCall[0].function.name,
-                    arguments: responseFunctionCall[0].function.arguments,
-                },
-            };
+        if (!response.usageMetadata ||
+            !response.usageMetadata.promptTokenCount ||
+            !response.usageMetadata.candidatesTokenCount) {
+            throw new Error('Not usage metadata');
         }
-        else {
-            throw new Error('Not supported Gemini Response');
+        const content = response.candidates.find((x) => x.content)?.content;
+        if (!content) {
+            throw new Error('Candidates has no content');
         }
-        let usage;
-        if (response.usage) {
-            usage = {
-                inputTokens: response.usage.prompt_tokens,
-                outputTokens: response.usage.completion_tokens,
-            };
-        }
-        else {
-            throw new Error('Unable to found usage info');
+        const nextItems = [];
+        for (const part of content.parts ?? []) {
+            if (part.text) {
+                nextItems.push({ type: 'botMessage', botMessage: { text: part.text } });
+            }
+            if (part.functionCall) {
+                const { id, name, args } = part.functionCall;
+                if (!name) {
+                    throw new Error('invalid function call');
+                }
+                nextItems.push({
+                    type: 'functionCall',
+                    functionCall: { id: id ?? Random.alphaNumericLowerCase(10), name, arguments: args && JSON.stringify(args) },
+                });
+            }
         }
-        return { chatItem, usage };
+        let usage = {
+            inputTokens: response.usageMetadata.promptTokenCount,
+            outputTokens: response.usageMetadata.candidatesTokenCount,
+        };
+        return { usage, nextItems };
     }
 };
 GoogleChatAdapter = __decorate([

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

@@ -6,7 +6,7 @@ import { singleton } from '../../../core/injection/index.js';
 let OpenaiChatAdapter = class OpenaiChatAdapter {
     openai = new OpenAI();
     logger = new Logger('wabot:openai-chat-adapter');
-    async nextItem(req) {
+    async nextItems(req) {
         const openIaInput = [];
         openIaInput.push({ role: 'system', content: req.systemPrompt });
         openIaInput.push(...this.mapChatItems(req.prevItems));
@@ -80,23 +80,6 @@ let OpenaiChatAdapter = class OpenaiChatAdapter {
         };
     }
     mapResponse(response) {
-        let chatItem;
-        if (response.output_text) {
-            chatItem = { type: 'botMessage', botMessage: { text: response.output_text } };
-        }
-        else if (response.output && response.output[0]?.type == 'function_call') {
-            chatItem = {
-                type: 'functionCall',
-                functionCall: {
-                    id: response.output[0].call_id,
-                    name: response.output[0].name,
-                    arguments: response.output[0].arguments,
-                },
-            };
-        }
-        else {
-            throw new Error('Not supported OpenIA Response');
-        }
         let usage;
         if (response.usage) {
             usage = {
@@ -107,7 +90,48 @@ let OpenaiChatAdapter = class OpenaiChatAdapter {
         else {
             throw new Error('Unable to found usage info');
         }
-        return { chatItem, usage };
+        const nextItems = [];
+        for (const output of response.output) {
+            if (output.type === 'message') {
+                for (const content of output.content) {
+                    if (content.type === 'output_text' && content.text) {
+                        nextItems.push({ type: 'botMessage', botMessage: { text: content.text } });
+                    }
+                }
+            }
+            else if (output.type === 'function_call') {
+                nextItems.push({
+                    type: 'functionCall',
+                    functionCall: { id: output.call_id, name: output.name, arguments: output.arguments },
+                });
+            }
+        }
+        return { usage, nextItems };
+        // let chatItem: IChatItem
+        // if (response.output_text) {
+        //   chatItem = { type: 'botMessage', botMessage: { text: response.output_text } }
+        // } else if (response.output && response.output[0]?.type == 'function_call') {
+        //   chatItem = {
+        //     type: 'functionCall',
+        //     functionCall: {
+        //       id: response.output[0].call_id,
+        //       name: response.output[0].name,
+        //       arguments: response.output[0].arguments,
+        //     },
+        //   }
+        // } else {
+        //   throw new Error('Not supported OpenIA Response')
+        // }
+        // let usage: ILanguageModelUsage
+        // if (response.usage) {
+        //   usage = {
+        //     inputTokens: response.usage.input_tokens,
+        //     outputTokens: response.usage.output_tokens,
+        //   }
+        // } else {
+        //   throw new Error('Unable to found usage info')
+        // }
+        // return { chatItem, usage }
     }
 };
 OpenaiChatAdapter = __decorate([

package/dist/src/addon/chat-bot/wabot/WabotChatAdapter.js

@@ -15,7 +15,7 @@ let WabotChatAdapter = class WabotChatAdapter {
             this.baseUrl = this.baseUrl.substring(0, this.baseUrl.length - 1);
         }
     }
-    async nextItem(req) {
+    async nextItems(req) {
         const response = await fetch(this.baseUrl + '/chat-bot/next-item', {
             method: 'post',
             headers: {

package/dist/src/addon/chat-controller/cmd/CmdChannel.js

@@ -1,21 +1,25 @@
-import { __decorate } from 'tslib';
+import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../../core/injection/index.js';
 import * as readline from 'readline';
 import * as fs from 'fs';
 import * as path from 'path';
 import { Random } from '../../../core/random/Random.js';
+import { Auth } from '../../../core/auth/Auth.js';
 
 var CmdChannel_1;
 const chatIdPath = '.cmd-channel/id.json';
 const authInfoPath = '.cmd-channel/auth-info.json';
 let CmdChannel = CmdChannel_1 = class CmdChannel {
-    authInfo = undefined;
+    auth;
     chatId = undefined;
     rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
     });
     callBack = null;
+    constructor(auth) {
+        this.auth = auth;
+    }
     listen(callback) {
         this.callBack = callback;
     }
@@ -44,8 +48,11 @@ let CmdChannel = CmdChannel_1 = class CmdChannel {
             };
             if (!this.callBack)
                 return;
-            if (this.authInfo === undefined) {
-                this.authInfo = readJsonFromFile(authInfoPath);
+            if (!this.auth.isAssigned()) {
+                const authInfo = readJsonFromFile(authInfoPath);
+                if (authInfo) {
+                    this.auth.assign(authInfo);
+                }
             }
             this.callBack({
                 chatConnection,
@@ -55,18 +62,18 @@ let CmdChannel = CmdChannel_1 = class CmdChannel {
                 reply: (message) => {
                     console.log(`\n[${message.senderName}]: ${message.text}\n`);
                     this.rl.prompt();
+                    if (this.auth.isAssigned()) {
+                        writeJsonToFile(authInfoPath, this.auth.require());
+                    }
                 },
-                authInfo: this.authInfo || undefined,
-                setAuthInfo: (authInfo) => {
-                    this.authInfo = authInfo || null;
-                    writeJsonToFile(authInfoPath, this.authInfo);
-                },
+                injectInstances: [[Auth, this.auth]],
             });
         });
     }
 };
 CmdChannel = CmdChannel_1 = __decorate([
-    injectable()
+    injectable(),
+    __metadata("design:paramtypes", [Auth])
 ], CmdChannel);
 function writeJsonToFile(filename, data) {
     const filePath = path.resolve(process.cwd(), filename);

package/dist/src/addon/chat-controller/socket/SocketChannel.js

@@ -7,8 +7,32 @@ import '../../../feature/socket-controller/metadata/SocketControllerMetadataStor
 import { runSocketControllers } from '../../../feature/socket-controller/runSocketControllers.js';
 import { Socket } from 'socket.io';
 import { SocketChannelConfig } from './SocketChannelConfig.js';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { isNotEmpty } from '../../../core/validation/validators/is-not-empty/@isNotEmpty.js';
+import { isString } from '../../../core/validation/validators/is-string/@isString.js';
+import { Auth } from '../../../core/auth/Auth.js';
 
 var SocketChannel_1;
+class SocketChannelReceivedMessage {
+    chatId;
+    senderName;
+    text;
+}
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], SocketChannelReceivedMessage.prototype, "chatId", void 0);
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], SocketChannelReceivedMessage.prototype, "senderName", void 0);
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], SocketChannelReceivedMessage.prototype, "text", void 0);
 let SocketChannel = SocketChannel_1 = class SocketChannel {
     config;
     callBack = null;
@@ -20,6 +44,10 @@ let SocketChannel = SocketChannel_1 = class SocketChannel {
     configController() {
         const channel = this;
         let SocketChannelController = class SocketChannelController {
+            auth;
+            constructor(auth) {
+                this.auth = auth;
+            }
             onMessage(message, socket) {
                 if (!channel.callBack)
                     return;
@@ -41,22 +69,23 @@ let SocketChannel = SocketChannel_1 = class SocketChannel {
                     reply: (message) => {
                         socket.emit('message', message);
                     },
-                    authInfo: socket.data.authInfo,
-                    setAuthInfo: (authInfo) => {
-                        socket.data.authInfo = authInfo;
-                    },
+                    injectInstances: [
+                        [Socket, socket],
+                        [Auth, this.auth],
+                    ],
                 });
             }
         };
         __decorate([
             onSocketEvent('message'),
             __metadata("design:type", Function),
-            __metadata("design:paramtypes", [Object, Socket]),
+            __metadata("design:paramtypes", [SocketChannelReceivedMessage, Socket]),
             __metadata("design:returntype", void 0)
         ], SocketChannelController.prototype, "onMessage", null);
         SocketChannelController = __decorate([
             socketController(channel.config.namespace),
-            handshakeMiddlewares(channel.config.handshakeMidlewares ?? [])
+            handshakeMiddlewares(channel.config.handshakeMidlewares ?? []),
+            __metadata("design:paramtypes", [Auth])
         ], SocketChannelController);
         this.controller = SocketChannelController;
     }
@@ -74,4 +103,4 @@ SocketChannel = SocketChannel_1 = __decorate([
     __metadata("design:paramtypes", [SocketChannelConfig])
 ], SocketChannel);
 
-export { SocketChannel };
+export { SocketChannel, SocketChannelReceivedMessage };

package/dist/src/core/validation/metadata/ValidationMetadataStore.js

@@ -58,6 +58,7 @@ let ValidationMetadataStore = class ValidationMetadataStore {
         constructors.unshift(modelConstructor);
         const modelValidators = {
             modelConstructor: modelConstructor,
+            modelHierarchy: constructors,
             properties: Object.assign({}, ...constructors.map((x) => this.getConstructorPropertiesValidatorsInfo(x))),
         };
         return modelValidators;

package/dist/src/core/validation/validators/is-record/@isRecord.js

@@ -0,0 +1,18 @@
+import { container } from '../../../injection/index.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
+import { validateIsRecord } from './validateIsRecord.js';
+
+function isRecord(keyType, valueType) {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsRecord,
+            validatorOptions: { keyType, valueType },
+        });
+    };
+}
+
+export { isRecord };

package/dist/src/core/validation/validators/is-record/validateIsRecord.js

@@ -0,0 +1,35 @@
+function validateIsRecord(value, options) {
+    if (value == null) {
+        return {
+            error: { description: `null is not allowed` },
+        };
+    }
+    if (typeof value !== 'object') {
+        return {
+            error: { description: `value should be an object` },
+        };
+    }
+    if (Array.isArray(value)) {
+        return {
+            error: { description: `array is not allowed` },
+        };
+    }
+    for (const key in value) {
+        if (typeof key !== options.keyType) {
+            return {
+                error: { description: `record keys should be ${options.keyType}` },
+            };
+        }
+        const keyValue = value[key];
+        if (typeof keyValue !== options.valueType) {
+            return {
+                error: { description: `record values should be ${options.valueType}` },
+            };
+        }
+    }
+    return {
+        value,
+    };
+}
+
+export { validateIsRecord };

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

@@ -1,5 +1,5 @@
 class ChatAdapter {
-    nextItem(req) {
+    nextItems(req) {
         throw new Error('Method not implemented.');
     }
 }

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

@@ -41,23 +41,27 @@ let ChatBot = class ChatBot {
             throw new Error(`Invalid ${this.mindset.constructor.name} - llms not found`);
         }
         const llm = llms[0];
-        const { chatItem: newItemData } = await this.adapter.nextItem({
+        const { nextItems: newItemsData } = await this.adapter.nextItems({
             model: llm.model,
             provider: llm.provider,
             systemPrompt,
             tools,
             prevItems: prevItems.map((x) => x.getData()),
         });
-        if (newItemData.type === 'functionCall') {
-            newItemData.functionCall.result = await this.mindset.callFunction(newItemData.functionCall.name, newItemData.functionCall.arguments ?? '{}');
+        for (const newItemData of newItemsData) {
+            if (newItemData.type === 'functionCall') {
+                newItemData.functionCall.result = await this.mindset.callFunction(newItemData.functionCall.name, newItemData.functionCall.arguments ?? '{}');
+            }
+            else if (newItemData.type === 'botMessage') {
+                newItemData.botMessage.senderName = identity.name;
+            }
+            const newChatItem = new ChatItem(newItemData);
+            await this.memory.create(newChatItem);
+            if (newItemData.type === 'botMessage') {
+                callback(newChatItem.botMessage);
+            }
         }
-        else if (newItemData.type === 'botMessage') {
-            newItemData.botMessage.senderName = identity.name;
-        }
-        const newChatItem = new ChatItem(newItemData);
-        await this.memory.create(newChatItem);
-        if (newChatItem.type === 'botMessage') {
-            callback(newChatItem.botMessage);
+        if (newItemsData.length == 0 || newItemsData[newItemsData.length - 1].type === 'botMessage') {
             return;
         }
         this.processLoop(callback);

package/dist/src/feature/chat-controller/runChatControllers.js

@@ -62,18 +62,15 @@ function runChatControllers(controllers) {
                     chat,
                     ...channelMessage,
                 });
+                if (channelMessage.injectInstances) {
+                    for (const [token, instance] of channelMessage.injectInstances) {
+                        chatContainer.registerInstance(token, instance);
+                    }
+                }
                 const chatController = chatContainer.resolve(channelMetadata.controllerConstructor);
                 const receivedMessage = {
                     message: channelMessage.message,
-                    reply: (message) => {
-                        channelMessage.reply(message);
-                        if (channelMessage.setAuthInfo) {
-                            const auth = chatContainer.resolve(Auth);
-                            if (auth.wasOverrided()) {
-                                channelMessage.setAuthInfo(auth['authInfo'] || undefined);
-                            }
-                        }
-                    },
+                    reply: channelMessage.reply,
                 };
                 chatController[channelMetadata.functionName](receivedMessage);
             });

package/dist/src/feature/rest-controller/RestRequest.js

@@ -0,0 +1,14 @@
+import { __decorate, __metadata } from 'tslib';
+import '../../core/injection/index.js';
+import '../../core/validation/metadata/ValidationMetadataStore.js';
+import { isRecord } from '../../core/validation/validators/is-record/@isRecord.js';
+
+class RestRequest {
+    headers;
+}
+__decorate([
+    isRecord('string', 'string'),
+    __metadata("design:type", Object)
+], RestRequest.prototype, "headers", void 0);
+
+export { RestRequest };

package/dist/src/feature/rest-controller/runRestControllers.js

@@ -1,13 +1,14 @@
 import { CustomError } from '../../core/error/CustomError.js';
 import { container } from '../../core/injection/index.js';
 import { Logger } from '../../core/logger/Logger.js';
-import '../../core/validation/metadata/ValidationMetadataStore.js';
-import { validateAndTransform } from '../../core/validation/validateAndTransform.js';
+import { validateModel } from '../../core/validation/core/validateModel.js';
+import { ValidationMetadataStore } from '../../core/validation/metadata/ValidationMetadataStore.js';
 import { ExpressProvider } from '../express/ExpressProvider.js';
 import { json, urlencoded } from 'express';
 import path__default from 'path';
 import { EXPRESS_REQ, EXPRESS_RES } from './injection-tokens.js';
 import { RestControllerMetadataStore } from './metadata/RestControllerMetadataStore.js';
+import { RestRequest } from './RestRequest.js';
 
 function buildRequest(req) {
     return Object.assign({}, req.body, req.query, req.params);
@@ -16,6 +17,7 @@ function runRestControllers(controllers) {
     const logger = new Logger('wabot:rest');
     const metadataStore = container.resolve(RestControllerMetadataStore);
     const expressProvider = container.resolve(ExpressProvider);
+    const validationMetadataStore = container.resolve(ValidationMetadataStore);
     const expressApp = expressProvider.getExpress();
     controllers.forEach((controller) => {
         const endPoints = metadataStore.getControllerEndPointsInfo(controller);
@@ -43,23 +45,26 @@ function runRestControllers(controllers) {
                     }
                     const controllerInstance = requestContainer.resolve(endPoint.controllerConstructor);
                     const endPointArgs = [];
-                    let defaultArgFound = false;
-                    for (let paramIndex = 0; paramIndex < endPoint.paramsTypes.length; paramIndex++) {
-                        const paramType = endPoint.paramsTypes[paramIndex];
-                        if (defaultArgFound) {
-                            throw new Error(`Cant determine de parameter ${paramIndex} value`);
+                    if (endPoint.paramsTypes.length > 1) {
+                        throw new Error(`rest controller endpoints should have zero or one parameter only`);
+                    }
+                    if (endPoint.paramsTypes.length === 1) {
+                        const paramType = endPoint.paramsTypes[0];
+                        if (typeof paramType !== 'function') {
+                            throw new Error(`invalid rest controller endpoint parameter type`);
                         }
-                        defaultArgFound = true;
-                        if (typeof paramType === 'function') {
-                            const { value, error } = validateAndTransform(buildRequest(req), paramType);
-                            if (error) {
-                                throw new CustomError({ httpCode: 400, message: error.description, info: error });
-                            }
-                            endPointArgs.push(value);
+                        const paramInfo = validationMetadataStore.getModelValidatorsInfo(paramType);
+                        const validableReq = paramInfo.modelHierarchy.includes(RestRequest)
+                            ? req
+                            : buildRequest(req);
+                        const { value, error } = validateModel(validableReq, paramInfo);
+                        if (error) {
+                            throw new CustomError({ httpCode: 400, message: error.description, info: error });
                         }
+                        endPointArgs.push(value);
                     }
                     const response = await controllerInstance[endPoint.functionName].apply(controllerInstance, endPointArgs);
-                    res.status(200).json(response);
+                    res.status(200).json(response ?? null);
                 }
                 catch (err) {
                     logger.error(err);

package/dist/src/feature/socket-controller/metadata/@handshakeMiddlewares.js

@@ -6,7 +6,7 @@ function handshakeMiddlewares(middlewares) {
         const store = container.resolve(SocketControllerMetadataStore);
         for (const mw of middlewares) {
             store.saveHandshakeMiddlewareMetadata({
-                controllerConstructor: target.constructor,
+                controllerConstructor: target,
                 middlewareConstructor: mw,
             });
         }

package/dist/src/feature/socket-controller/runSocketControllers.js

@@ -25,6 +25,7 @@ function runSocketControllers(controllers) {
                     await middleware.handle(socket, connectionContainer);
                 }
                 socket.data.connectionContainer = connectionContainer;
+                connectionContainer.registerInstance(Socket, socket);
                 next();
             }
             catch (err) {

package/dist/src/index.d.ts

@@ -175,6 +175,7 @@ interface IPropertyValidatorInfo {
 }
 type IModelValidatorsInfo<V> = {
     modelConstructor: IConstructor<V>;
+    modelHierarchy: IConstructor<any>[];
     properties: {
         [prop: string]: {
             isOptional?: boolean;
@@ -265,6 +266,14 @@ interface IValidateMinOptions {
 }
 declare function validateMin(value: any, options: IValidateMinOptions): IValidationResult<any>;
 
+declare function isRecord(keyType: 'number' | 'string', valueType: 'number' | 'string' | 'boolean'): (target: object, propertyKey: string | symbol) => void;
+
+interface IValidateIsRecordOptions {
+    keyType: 'string' | 'number';
+    valueType: 'string' | 'number' | 'boolean';
+}
+declare function validateIsRecord(value: any, options: IValidateIsRecordOptions): IValidationResult<any>;
+
 declare class Mapper {
     map<T>(data: IValidateInputShape<T>, ctor: IConstructor<T>): T;
 }
@@ -615,24 +624,24 @@ interface ILanguageModelUsage {
     outputTokens: number;
 }
 
-interface IChatAdapterNextItemReq {
+interface IChatAdapterNextItemsReq {
     model: string;
     systemPrompt: string;
     tools: IMindsetTool[];
     prevItems: IChatItem[];
 }
-interface IChatAdapterNextItemRes {
-    chatItem: IChatItem;
+interface IChatAdapterNextItemsRes {
+    nextItems: IChatItem[];
     usage: ILanguageModelUsage;
 }
 interface IChatAdapter {
-    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
+    nextItems(req: IChatAdapterNextItemsReq): Promise<IChatAdapterNextItemsRes>;
 }
 
 declare class ChatAdapter implements IChatAdapter {
-    nextItem(req: IChatAdapterNextItemReq & {
+    nextItems(req: IChatAdapterNextItemsReq & {
         provider?: string;
-    }): Promise<IChatAdapterNextItemRes>;
+    }): Promise<IChatAdapterNextItemsRes>;
 }
 
 type IChatItemData = IEntityData & IChatItem;
@@ -709,8 +718,7 @@ interface IReceivedMessage {
 
 interface IChannelMessage extends IReceivedMessage {
     chatConnection: IChatConnection;
-    authInfo?: IStorableData;
-    setAuthInfo?: (authInfo: IStorableData | undefined) => void;
+    injectInstances?: [any, any][];
 }
 
 interface IChatChannel {
@@ -916,6 +924,10 @@ declare function runRestControllers(controllers: IConstructor<any>[]): void;
 declare const EXPRESS_REQ = "EXPRESS_REQ";
 declare const EXPRESS_RES = "EXPRESS_RES";
 
+declare class RestRequest {
+    headers?: Record<string, string>;
+}
+
 declare class SocketServerProvider {
     private httpServerProvider;
     private socketServer;
@@ -1176,7 +1188,7 @@ declare class AnthropicChatAdapter implements IChatAdapter {
     private anthropic;
     private logger;
     constructor(env: Env);
-    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
+    nextItems(req: IChatAdapterNextItemsReq): Promise<IChatAdapterNextItemsRes>;
     private mapChatItems;
     private mapHumanMessage;
     private mapBotMessage;
@@ -1189,7 +1201,7 @@ declare class DeepSeekChatAdapter implements IChatAdapter {
     private deepSeek;
     private logger;
     constructor();
-    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
+    nextItems(req: IChatAdapterNextItemsReq): Promise<IChatAdapterNextItemsRes>;
     private mapChatItems;
     private mapHumanMessage;
     private mapBotMessage;
@@ -1198,12 +1210,14 @@ declare class DeepSeekChatAdapter implements IChatAdapter {
     private mapResponse;
 }
 
+interface GoogleChatAdapterV2Options {
+    apiKey?: string;
+}
 declare class GoogleChatAdapter implements IChatAdapter {
-    private env;
-    private openai;
-    private logger;
+    private ai;
+    private readonly logger;
     constructor(env: Env);
-    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
+    nextItems(req: IChatAdapterNextItemsReq): Promise<IChatAdapterNextItemsRes>;
     private mapChatItems;
     private mapHumanMessage;
     private mapBotMessage;
@@ -1215,7 +1229,7 @@ declare class GoogleChatAdapter implements IChatAdapter {
 declare class OpenaiChatAdapter implements IChatAdapter {
     private openai;
     private logger;
-    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
+    nextItems(req: IChatAdapterNextItemsReq): Promise<IChatAdapterNextItemsRes>;
     private mapChatItems;
     private mapConectionMessage;
     private mapBotMessage;
@@ -1257,16 +1271,17 @@ declare class WabotChatAdapter implements IChatAdapter {
     private baseUrl;
     private logger;
     constructor(env: Env);
-    nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
+    nextItems(req: IChatAdapterNextItemsReq): Promise<IChatAdapterNextItemsRes>;
 }
 
 declare function cmd(): (target: object, propertyKey: string | symbol) => void;
 
 declare class CmdChannel implements IChatChannel {
-    private authInfo;
+    private auth;
     private chatId;
     private rl;
     private callBack;
+    constructor(auth: Auth<any>);
     listen(callback: (message: IChannelMessage) => void): void;
     connect(): void;
 }
@@ -1291,6 +1306,11 @@ interface ISocketChannelReceivedMessage {
     senderName: string;
     text: string;
 }
+declare class SocketChannelReceivedMessage implements ISocketChannelReceivedMessage {
+    chatId: string;
+    senderName: string;
+    text: string;
+}
 declare class SocketChannel implements IChatChannel {
     private config;
     private callBack;
@@ -1618,4 +1638,4 @@ declare function HtmlModule(options: IHtmlModuleOptions): {
     new (): {};
 };
 
-export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Command, CommandMetadataStore, Container, ControllerMetadataStore, CustomError, DeepSeekChatAdapter, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, ExpressProvider, GoogleChatAdapter, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemReq, type IChatAdapterNextItemRes, 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 ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IGetWhatsAppTemplateRequest, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobEvent, type IJobEventListener, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPrimitive, type IPropertyValidatorInfo, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRestControllerConfig, type IRestControllerMetadata, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, 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 IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsappChannelConfig, type IchatControllerConfig, Job, JobRepository, JobRunner, JobsEventsHub, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenaiChatAdapter, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, SocketChannel, SocketChannelConfig, SocketControllerMetadataStore, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT, WabotChatAdapter, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByCloudApi, WhatsAppReceiverByWabotProxy, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByWabotProxy, WhatsAppWabotProxyConnection, WhatsappChannelConfig, apiKeyGuard, apiKeyHandshakeGuard, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, container, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isString, jwtGuard, jwtHandshakeGuard, max, middleware, min, mindset, mindsetFunction, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, onSocketEvent, param, readJsonFromFile, restController, runAsyncCommandHandlers, runChatControllers, runRestControllers, runSocketControllers, scoped, singleton, socket, socketController, telegram, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsApp, writeJsonToFile };
+export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Command, CommandMetadataStore, Container, ControllerMetadataStore, CustomError, DeepSeekChatAdapter, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, 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 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 ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IGetWhatsAppTemplateRequest, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobEvent, type IJobEventListener, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPrimitive, type IPropertyValidatorInfo, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRestControllerConfig, type IRestControllerMetadata, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateIsRecordOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, 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 IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsappChannelConfig, type IchatControllerConfig, Job, JobRepository, JobRunner, JobsEventsHub, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenaiChatAdapter, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, RestRequest, SocketChannel, SocketChannelConfig, SocketChannelReceivedMessage, SocketControllerMetadataStore, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT, WabotChatAdapter, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByCloudApi, WhatsAppReceiverByWabotProxy, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByWabotProxy, WhatsAppWabotProxyConnection, WhatsappChannelConfig, apiKeyGuard, apiKeyHandshakeGuard, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, container, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isRecord, isString, jwtGuard, jwtHandshakeGuard, max, middleware, min, mindset, mindsetFunction, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, onSocketEvent, param, readJsonFromFile, restController, runAsyncCommandHandlers, runChatControllers, runRestControllers, runSocketControllers, scoped, singleton, socket, socketController, telegram, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsRecord, validateIsString, validateMax, validateMin, validateModel, whatsApp, writeJsonToFile };

package/dist/src/index.js

@@ -34,6 +34,8 @@ export { max } from './core/validation/validators/max/@max.js';
 export { validateMax } from './core/validation/validators/max/validateMax.js';
 export { min } from './core/validation/validators/min/@min.js';
 export { validateMin } from './core/validation/validators/min/validateMin.js';
+export { isRecord } from './core/validation/validators/is-record/@isRecord.js';
+export { validateIsRecord } from './core/validation/validators/is-record/validateIsRecord.js';
 export { command } from './feature/async/@command.js';
 export { commandHandler } from './feature/async/@commandHandler.js';
 export { Async } from './feature/async/Async.js';
@@ -83,6 +85,7 @@ export { restController } from './feature/rest-controller/metadata/@restControll
 export { RestControllerMetadataStore } from './feature/rest-controller/metadata/RestControllerMetadataStore.js';
 export { runRestControllers } from './feature/rest-controller/runRestControllers.js';
 export { EXPRESS_REQ, EXPRESS_RES } from './feature/rest-controller/injection-tokens.js';
+export { RestRequest } from './feature/rest-controller/RestRequest.js';
 export { SocketServerProvider } from './feature/socket/SocketServerProvider.js';
 export { handshakeMiddlewares } from './feature/socket-controller/metadata/@handshakeMiddlewares.js';
 export { socketController } from './feature/socket-controller/metadata/@socketController.js';
@@ -122,7 +125,7 @@ export { WabotChatAdapter } from './addon/chat-bot/wabot/WabotChatAdapter.js';
 export { cmd } from './addon/chat-controller/cmd/@cmd.js';
 export { CmdChannel, readJsonFromFile, writeJsonToFile } from './addon/chat-controller/cmd/CmdChannel.js';
 export { socket } from './addon/chat-controller/socket/@socket.js';
-export { SocketChannel } from './addon/chat-controller/socket/SocketChannel.js';
+export { SocketChannel, SocketChannelReceivedMessage } from './addon/chat-controller/socket/SocketChannel.js';
 export { SocketChannelConfig } from './addon/chat-controller/socket/SocketChannelConfig.js';
 export { telegram } from './addon/chat-controller/telegram/@telegram.js';
 export { TelegramChannelConfig } from './addon/chat-controller/telegram/TelegramChannelConfig.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.2.0-beta.9",
+  "version": "0.2.1-beta.1",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",
@@ -12,7 +12,7 @@
   "scripts": {
     "build": "rollup --config rollup.config.ts --configPlugin typescript && tsup --dts-only --format esm --out-dir dist/src src/index.ts",
     "test:units": "node --import @yucacodes/ts/src/custom-import.mjs  --test './src/**/*.unit.test.ts'",
-    "test:integration": "node --import @yucacodes/ts/src/custom-import.mjs  --test './src/**/*.integration.test.ts'",
+    "test:integration": "node --import ./env.mjs --import @yucacodes/ts/src/custom-import.mjs  --test './src/**/*.integration.test.ts'",
     "fmt": "prettier --write .",
     "fmt:check": "prettier --check .",
     "types:check": "tsc --noEmit",
@@ -24,10 +24,6 @@
     "@rollup/plugin-json": "6.1.0",
     "@rollup/plugin-node-resolve": "16.0.1",
     "@rollup/plugin-typescript": "12.1.2",
-    "@types/big.js": "^6.2.2",
-    "@types/html-to-text": "^9.0.4",
-    "@types/node": "22.14.1",
-    "@types/react": "^19.1.2",
     "@yucacodes/ts": "^0.0.4",
     "prettier": "^3.5.3",
     "resend": "^4.4.1",
@@ -38,9 +34,12 @@
   "peerDependencies": {
     "@anthropic-ai/sdk": "^0.60.0",
     "@google/genai": "^1.16.0",
+    "@types/big.js": "^6.2.2",
     "@types/debug": "^4.1.12",
     "@types/express": "^5.0.1",
+    "@types/html-to-text": "^9.0.4",
     "@types/jsonwebtoken": "^9.0.10",
+    "@types/node": "22.14.1",
     "@types/pg": "^8.11.14",
     "@yucacodes/ts": "^0.0.4",
     "big.js": "^7.0.1",