@wabot-dev/framework 0.1.0-beta.1 → 0.1.0-beta.11

package/dist/src/ai/deepseek/DeepSeekChatBotAdapter.js

@@ -1,15 +1,13 @@
 import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../injection/index.js';
 import { OpenAI } from 'openai';
-import 'reflect-metadata';
-import '../../mindset/metadata/MindsetMetadataStore.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
-import { MindsetOperator } from '../../mindset/MindsetOperator.js';
 import 'uuid';
 import '../../chatbot/metadata/ChatBotMetadataStore.js';
 import '../../chatbot/ChatBot.js';
 import { ChatBotAdapter } from '../../chatbot/ChatBotAdapter.js';
+import 'reflect-metadata';
+import '../../mindset/metadata/MindsetMetadataStore.js';
+import { MindsetOperator } from '../../mindset/MindsetOperator.js';
 
 let DeepSeekChatBotAdapter = class DeepSeekChatBotAdapter extends ChatBotAdapter {
     deepSeek;
@@ -23,7 +21,7 @@ let DeepSeekChatBotAdapter = class DeepSeekChatBotAdapter extends ChatBotAdapter
         this.model = model || 'deepseek-chat';
         this.deepSeek = new OpenAI({
             apiKey: apiKey,
-            baseURL: baseURL
+            baseURL: baseURL,
         });
     }
     validateEnvVariables(envVariables) {
@@ -38,14 +36,15 @@ let DeepSeekChatBotAdapter = class DeepSeekChatBotAdapter extends ChatBotAdapter
         const tools = (await this.mindset.allFunctionsDescriptors()).map((fn) => {
             const parameters = { ...fn.parameters, additionalProperties: false, type: 'object' };
             return {
-                type: 'function', function: { name: fn.name, description: fn.description, parameters, strict: true }
+                type: 'function',
+                function: { name: fn.name, description: fn.description, parameters, strict: true },
             };
         });
         const response = await this.deepSeek.chat.completions.create({
             model: this.model,
             messages: [{ role: 'system', content: systemPrompt }, ...this.mapChatItems(chatItems)],
             tools: tools,
-            tool_choice: 'auto'
+            tool_choice: 'auto',
         });
         let newChatItem;
         const { tool_calls: responseFunctionCall, content: responseText } = response.choices?.[0]?.message ?? {};
@@ -85,15 +84,15 @@ let DeepSeekChatBotAdapter = class DeepSeekChatBotAdapter extends ChatBotAdapter
                             type: 'function',
                             function: {
                                 name: itemData.content.name,
-                                arguments: JSON.stringify(itemData.content.arguments)
-                            }
-                        }
-                    ]
+                                arguments: JSON.stringify(itemData.content.arguments),
+                            },
+                        },
+                    ],
                 });
                 deepSeekInput.push({
                     role: 'tool',
                     tool_call_id: itemData.content.id,
-                    content: itemData.content.result
+                    content: itemData.content.result,
                 });
             }
         }

package/dist/src/ai/openia/OpenaiChatBotAdapter.js

@@ -1,19 +1,19 @@
 import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../injection/index.js';
 import { OpenAI } from 'openai';
-import 'reflect-metadata';
-import '../../mindset/metadata/MindsetMetadataStore.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
-import { MindsetOperator } from '../../mindset/MindsetOperator.js';
 import 'uuid';
 import '../../chatbot/metadata/ChatBotMetadataStore.js';
 import '../../chatbot/ChatBot.js';
 import { ChatBotAdapter } from '../../chatbot/ChatBotAdapter.js';
+import 'reflect-metadata';
+import '../../mindset/metadata/MindsetMetadataStore.js';
+import { MindsetOperator } from '../../mindset/MindsetOperator.js';
+import { Logger } from '../../logger/Logger.js';
 
 let OpenaiChatBotAdapter = class OpenaiChatBotAdapter extends ChatBotAdapter {
     openai = new OpenAI();
     model;
+    logger = new Logger('wabot:openai-chat-bot-adapter');
     constructor(mindset) {
         super(mindset);
         const model = process.env.OPENAI_CHAT_MODEL;
@@ -28,11 +28,13 @@ let OpenaiChatBotAdapter = class OpenaiChatBotAdapter extends ChatBotAdapter {
             const parameters = { ...fn.parameters, additionalProperties: false, type: 'object' };
             return { ...fn, type: 'function', parameters, strict: true };
         });
-        const response = await this.openai.responses.create({
+        const request = {
             model: this.model,
             input: [{ role: 'system', content: systemPrompt }, ...this.mapChatItems(chatItems)],
             tools,
-        });
+        };
+        this.logger.debug(`Call Api with Request: ${JSON.stringify(request)}`);
+        const response = await this.openai.responses.create(request);
         let newChatItem;
         if (response.output_text) {
             newChatItem = await this.buildBotMessageItem(response.output_text);

package/dist/src/channels/cmd/@cmd.js

@@ -1,11 +1,7 @@
 import '../../controller/channel/ChatResolver.js';
 import '../../controller/channel/UserResolver.js';
 import { container } from '../../injection/index.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import { CmdChannel } from './CmdChannel.js';
 
 function cmd() {

package/dist/src/channels/cmd/CmdChannel.js

@@ -2,11 +2,7 @@ import { __decorate, __metadata } from 'tslib';
 import { ChatResolver } from '../../controller/channel/ChatResolver.js';
 import { UserResolver } from '../../controller/channel/UserResolver.js';
 import { injectable } from '../../injection/index.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import * as readline from 'readline';
 
 var CmdChannel_1;

package/dist/src/channels/express/ExpressProvider.js

@@ -0,0 +1,46 @@
+import { __decorate, __metadata } from 'tslib';
+import { HttpServerProvider } from '../http/HttpServerProvider.js';
+import express from 'express';
+import { singleton } from 'tsyringe';
+import bodyParser from 'body-parser';
+import { Logger } from '../../logger/Logger.js';
+
+let ExpressProvider = class ExpressProvider {
+    httpServerProvider;
+    expressApp = null;
+    logger = new Logger('wabot:express');
+    constructor(httpServerProvider) {
+        this.httpServerProvider = httpServerProvider;
+    }
+    getExpress() {
+        if (!this.expressApp) {
+            this.expressApp = this.createExpress();
+        }
+        return this.expressApp;
+    }
+    listen() {
+        this.httpServerProvider.listen();
+    }
+    createExpress() {
+        const expressApp = express();
+        expressApp.use(bodyParser.json());
+        expressApp.use((req, res, next) => {
+            const start = process.hrtime();
+            res.on('finish', () => {
+                const [seconds, nanoseconds] = process.hrtime(start);
+                const ms = (seconds * 1000 + nanoseconds / 1e6).toFixed(2);
+                this.logger.trace(`${req.method} ${req.originalUrl} ${res.statusCode} - ${ms}ms`);
+            });
+            next();
+        });
+        const httpServer = this.httpServerProvider.getHttpServer();
+        httpServer.on('request', expressApp);
+        return expressApp;
+    }
+};
+ExpressProvider = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [HttpServerProvider])
+], ExpressProvider);
+
+export { ExpressProvider };

package/dist/src/channels/http/HttpServerProvider.js

@@ -0,0 +1,31 @@
+import { __decorate } from 'tslib';
+import { Logger } from '../../logger/Logger.js';
+import { Server } from 'http';
+import { singleton } from 'tsyringe';
+
+let HttpServerProvider = class HttpServerProvider {
+    server = null;
+    listening = false;
+    logger = new Logger('wabot:http');
+    getHttpServer() {
+        if (!this.server) {
+            this.server = new Server();
+        }
+        return this.server;
+    }
+    listen() {
+        if (!this.server || this.listening) {
+            return;
+        }
+        this.listening = true;
+        const PORT = process.env.PORT || 3000;
+        this.server.listen(PORT, () => {
+            this.logger.info(`server listenig on port ${PORT}`);
+        });
+    }
+};
+HttpServerProvider = __decorate([
+    singleton()
+], HttpServerProvider);
+
+export { HttpServerProvider };

package/dist/src/channels/{socket-io → socket}/@socket.js

@@ -1,11 +1,7 @@
 import '../../controller/channel/ChatResolver.js';
 import '../../controller/channel/UserResolver.js';
 import { container } from '../../injection/index.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import { SocketChannel } from './SocketChannel.js';
 import { SocketChannelConfig } from './SocketChannelConfig.js';
 

package/dist/src/channels/{socket-io → socket}/SocketChannel.js

@@ -1,26 +1,25 @@
-import { __decorate, __param, __metadata } from 'tslib';
+import { __decorate, __metadata } from 'tslib';
 import { SocketChannelConfig } from './SocketChannelConfig.js';
-import { injectable, inject } from '../../injection/index.js';
+import { injectable } from '../../injection/index.js';
 import { ChatResolver } from '../../controller/channel/ChatResolver.js';
 import { UserResolver } from '../../controller/channel/UserResolver.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import { SocketIoApp } from '../../controller/socket.io/SocketIO.js';
+import { SocketServerProvider } from './SocketServerProvider.js';
 
 var SocketChannel_1;
 let SocketChannel = SocketChannel_1 = class SocketChannel {
     config;
-    server;
+    socketServerProvider;
     chatResolver;
     userResolver;
     callBack = null;
-    constructor(config, server, chatResolver, userResolver) {
+    server;
+    constructor(config, socketServerProvider, chatResolver, userResolver) {
         this.config = config;
-        this.server = server;
+        this.socketServerProvider = socketServerProvider;
         this.chatResolver = chatResolver;
         this.userResolver = userResolver;
+        this.server = this.socketServerProvider.getSocketServer();
     }
     listen(callback) {
         this.callBack = callback;
@@ -66,12 +65,14 @@ let SocketChannel = SocketChannel_1 = class SocketChannel {
                 });
             });
         });
+        this.socketServerProvider.listen();
     }
 };
 SocketChannel = SocketChannel_1 = __decorate([
     injectable(),
-    __param(1, inject(SocketIoApp)),
-    __metadata("design:paramtypes", [SocketChannelConfig, Function, ChatResolver,
+    __metadata("design:paramtypes", [SocketChannelConfig,
+        SocketServerProvider,
+        ChatResolver,
         UserResolver])
 ], SocketChannel);
 

package/dist/src/channels/socket/SocketServerProvider.js

@@ -0,0 +1,50 @@
+import { __decorate, __metadata } from 'tslib';
+import { Logger } from '../../logger/Logger.js';
+import { HttpServerProvider } from '../http/HttpServerProvider.js';
+import { Server } from 'socket.io';
+import { singleton } from 'tsyringe';
+
+let SocketServerProvider = class SocketServerProvider {
+    httpServerProvider;
+    socketServer = null;
+    logger = new Logger('wabot:socket');
+    constructor(httpServerProvider) {
+        this.httpServerProvider = httpServerProvider;
+    }
+    getSocketServer() {
+        if (!this.socketServer) {
+            this.socketServer = this.createSocketServer();
+        }
+        return this.socketServer;
+    }
+    listen() {
+        this.httpServerProvider.listen();
+    }
+    createSocketServer() {
+        const httpServer = this.httpServerProvider.getHttpServer();
+        const socketServer = new Server(httpServer, {
+            cors: {
+                origin: '*',
+            },
+        });
+        socketServer.on('connection', (socket) => {
+            this.logger.trace(`socket:${socket.id} connection`);
+            socket.onAny((event) => {
+                this.logger.trace(`socket:${socket.id} emmits ${event}`);
+            });
+            socket.on('disconnect', (reason) => {
+                this.logger.trace(`socket:${socket.id} disconnect with reason: ${reason}`);
+            });
+        });
+        httpServer.on('listening', () => {
+            this.logger.info(`socket server listening`);
+        });
+        return socketServer;
+    }
+};
+SocketServerProvider = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [HttpServerProvider])
+], SocketServerProvider);
+
+export { SocketServerProvider };

package/dist/src/channels/telegram/@telegram.js

@@ -1,11 +1,7 @@
 import { container } from '../../injection/index.js';
 import '../../controller/channel/ChatResolver.js';
 import '../../controller/channel/UserResolver.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import { TelegramChannel } from './TelegramChannel.js';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 

package/dist/src/channels/telegram/TelegramChannel.js

@@ -2,11 +2,7 @@ import { __decorate, __metadata } from 'tslib';
 import { ChatResolver } from '../../controller/channel/ChatResolver.js';
 import { UserResolver } from '../../controller/channel/UserResolver.js';
 import { injectable } from '../../injection/index.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import { Bot } from 'grammy';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 

package/dist/src/channels/wabot/WabotDevConnection.js

@@ -0,0 +1,57 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../injection/index.js';
+import { Logger } from '../../logger/Logger.js';
+import { io } from 'socket.io-client';
+import { devEmitEvent } from './WabotDevSocketContracts.js';
+
+var WabotDevConnection_1;
+let WabotDevConnection = WabotDevConnection_1 = class WabotDevConnection {
+    devProxy;
+    devProxySocket = null;
+    devToken;
+    logger = new Logger('wabot:dev-connection');
+    static isTokenAvailable() {
+        return !!process.env.WABOT_DEV_TOKEN;
+    }
+    constructor() {
+        if (!WabotDevConnection_1.isTokenAvailable()) {
+            throw new Error('WABOT_DEV_TOKEN is not set in environment variables');
+        }
+        this.devToken = process.env.WABOT_DEV_TOKEN;
+        this.devProxy = process.env.WABOT_DEV_PROXY ?? 'https://proxy.wabot.dev';
+    }
+    async getSocket() {
+        if (this.devProxySocket) {
+            return this.devProxySocket;
+        }
+        return new Promise((resolve, reject) => {
+            const devProxySocket = io(this.devProxy, { autoConnect: false });
+            devProxySocket.on('connect', async () => {
+                try {
+                    const req = {
+                        token: this.devToken,
+                    };
+                    this.logger.debug('dev connection request');
+                    const ack = await devProxySocket.emitWithAck(devEmitEvent.DEV_CONNECTION, req);
+                    if (ack != 'OK') {
+                        return reject(new Error('Dev connection failed'));
+                    }
+                    this.logger.debug('success dev connection');
+                    this.devProxySocket = devProxySocket;
+                    resolve(devProxySocket);
+                }
+                catch (err) {
+                    this.logger.error(err);
+                    reject(err);
+                }
+            });
+            devProxySocket.connect();
+        });
+    }
+};
+WabotDevConnection = WabotDevConnection_1 = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [])
+], WabotDevConnection);
+
+export { WabotDevConnection };

package/dist/src/channels/{whatsapp/WhatsAppDevSocketContracts.js → wabot/WabotDevSocketContracts.js}

@@ -1,10 +1,10 @@
-const devWhatsAppListentEvent = {
+const devListentEvent = {
     DEV_WATSAPP_WEBHOOK: 'dev-whatsapp-webhook',
 };
-const devWhatsappEmitEvent = {
+const devEmitEvent = {
     DEV_CONNECTION: 'dev-connection',
     DEV_SEND_WHATSAPP: 'dev-send-whatsapp',
     DEV_SEND_WHATSAPP_TEMPLATE: 'dev-send-whatsapp-template',
 };
 
-export { devWhatsAppListentEvent, devWhatsappEmitEvent };
+export { devEmitEvent, devListentEvent };

package/dist/src/channels/whatsapp/@whatsapp.js

@@ -2,11 +2,7 @@ import { container } from '../../injection/index.js';
 import { WhatsappChannelConfig } from './WhatsAppChannelConfig.js';
 import '../../controller/channel/ChatResolver.js';
 import '../../controller/channel/UserResolver.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import { WhatsAppChannel } from './WhatsAppChannel.js';
 
 function whatsapp(config) {

package/dist/src/channels/whatsapp/EnvWhatsAppRepository.js

@@ -0,0 +1,49 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../injection/index.js';
+import { WhatsApp } from './WhatsApp.js';
+import { WabotEnv } from '../../env/WabotEnv.js';
+
+let EnvWhatsAppRepository = class EnvWhatsAppRepository {
+    env;
+    constructor(env) {
+        this.env = env;
+    }
+    async findBySlug(slug) {
+        const whatsApp = this.getFromEnvVars();
+        if (whatsApp.getSlug() !== slug) {
+            throw new Error(`Not found WhatsApp configuration in env variables for the required slug '${slug}'`);
+        }
+        return whatsApp;
+    }
+    async findByBusinessNumber(number) {
+        const whatsApp = this.getFromEnvVars();
+        if (!whatsApp.getBussinessNumber(number)) {
+            throw new Error(`Not found WhatsApp configuration in env variables for the required number '${number}'`);
+        }
+        return whatsApp;
+    }
+    getFromEnvVars() {
+        const whatsApp = new WhatsApp({
+            verifyToken: this.env.requireString('WHATSAPP_HOOK_TOKEN'),
+            slug: this.env.requireString('WHATSAPP_HOOK_SLUG'),
+            appSecret: this.env.requireString('WHATSAPP_APP_SECRET'),
+            businessAccount: {
+                id: this.env.requireString('WHATSAPP_ACCOUNT_ID'),
+            },
+            accessToken: this.env.requireString('WHATSAPP_ACCESS_TOKEN'),
+            businessNumbers: [
+                {
+                    id: this.env.requireString('WHATSAPP_BUSINESS_NUMBER_ID'),
+                    number: this.env.requireString('WHATSAPP_BUSINESS_NUMBER'),
+                },
+            ],
+        });
+        return whatsApp;
+    }
+};
+EnvWhatsAppRepository = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [WabotEnv])
+], EnvWhatsAppRepository);
+
+export { EnvWhatsAppRepository };

package/dist/src/channels/whatsapp/PgWhatsAppRepository.js

@@ -0,0 +1,41 @@
+import { __decorate, __metadata } from 'tslib';
+import { Pool } from 'pg';
+import { WhatsApp } from './WhatsApp.js';
+import { singleton } from '../../injection/index.js';
+import { PgCrudRepository } from '../../repository/pg/PgCrudRepository.js';
+
+let PgWhatsAppRepository = class PgWhatsAppRepository extends PgCrudRepository {
+    constructor(pool) {
+        super(pool, {
+            table: 'whatsapp',
+            constructor: WhatsApp,
+            schema: 'wabot',
+        });
+    }
+    async findBySlug(slug) {
+        const sql = `
+      SELECT ${this.columns}
+      FROM ${this.table}
+      WHERE data @> $1
+      LIMIT 1
+    `;
+        const items = await this.query(sql, [JSON.stringify({ slug })]);
+        return items.at(0) ?? null;
+    }
+    async findByBusinessNumber(number) {
+        const sql = `
+      SELECT ${this.columns}
+      FROM ${this.table}
+      WHERE data->'businessNumbers' @> $1
+      LIMIT 1
+    `;
+        const items = await this.query(sql, [JSON.stringify([{ number }])]);
+        return items.at(0) ?? null;
+    }
+};
+PgWhatsAppRepository = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Pool])
+], PgWhatsAppRepository);
+
+export { PgWhatsAppRepository };

package/dist/src/channels/whatsapp/WhatsApp.js

@@ -0,0 +1,32 @@
+import '../../core/chat/repository/IChatRepository.js';
+import { Persistent } from '../../core/Persistent.js';
+import '../../core/user/IUserRepository.js';
+
+class WhatsApp extends Persistent {
+    getVerifyToken() {
+        return this.data.verifyToken;
+    }
+    getSlug() {
+        return this.data.slug;
+    }
+    getBusinessAccount() {
+        return this.data.businessAccount;
+    }
+    getAppSecret() {
+        return this.data.appSecret;
+    }
+    getBusinessNumbers() {
+        return this.data.businessNumbers;
+    }
+    getAccessToken() {
+        return this.data.accessToken;
+    }
+    hasBusinessNumber(number) {
+        return this.data.businessNumbers.some((x) => x.number === number);
+    }
+    getBussinessNumber(number) {
+        return this.data.businessNumbers.find((x) => x.number === number) ?? null;
+    }
+}
+
+export { WhatsApp };

package/dist/src/channels/whatsapp/WhatsAppChannel.js

@@ -2,52 +2,54 @@ import { __decorate, __metadata } from 'tslib';
 import { ChatResolver } from '../../controller/channel/ChatResolver.js';
 import { UserResolver } from '../../controller/channel/UserResolver.js';
 import { injectable } from '../../injection/index.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
-import { WabotEnv } from '../../env/WabotEnv.js';
 import { Logger } from '../../logger/Logger.js';
 import { WhatsappChannelConfig } from './WhatsAppChannelConfig.js';
-import { WhatsAppDevConnection } from './WhatsAppDevConnection.js';
-import { WhatsAppProdConnection } from './WhatsAppProdConnection.js';
+import { WhatsAppReceiver } from './WhatsAppReceiver.js';
+import { WhatsAppSender } from './WhatsAppSender.js';
 
 let WhatsAppChannel = class WhatsAppChannel {
     config;
     chatResolver;
     userResolver;
-    wabotEnv;
+    sender;
+    receiver;
     logger = new Logger('wabot:whatsapp-channel');
-    whatsAppConection;
-    constructor(config, chatResolver, userResolver, wabotEnv, devConnection, prodConnection) {
+    constructor(config, chatResolver, userResolver, sender, receiver) {
         this.config = config;
         this.chatResolver = chatResolver;
         this.userResolver = userResolver;
-        this.wabotEnv = wabotEnv;
-        this.whatsAppConection = this.wabotEnv.isProduction() ? prodConnection : devConnection;
+        this.sender = sender;
+        this.receiver = receiver;
     }
     listen(callback) {
-        this.whatsAppConection.listenMessage(this.config.number, async (message) => {
-            try {
-                const chat = await this.chatResolver.resolve(message.chatConnection);
-                const user = await this.userResolver.resolve(message.userConnection);
-                callback({
-                    chat,
-                    user,
-                    message,
-                    reply: (replyMessage) => {
-                        this.whatsAppConection.sendWhatsApp(this.config.number, message.userConnection.id, replyMessage);
-                    },
-                });
-            }
-            catch (err) {
-                this.logger.error(err);
-            }
+        this.receiver.listenMessage({
+            to: this.config.number,
+            listener: async (message) => {
+                try {
+                    const chat = await this.chatResolver.resolve(message.chatConnection);
+                    const user = await this.userResolver.resolve(message.userConnection);
+                    callback({
+                        chat,
+                        user,
+                        message,
+                        reply: (replyMessage) => {
+                            this.sender.sendWhatsApp({
+                                from: this.config.number,
+                                to: message.userConnection.id,
+                                message: replyMessage,
+                            });
+                        },
+                    });
+                }
+                catch (err) {
+                    this.logger.error(err);
+                }
+            },
         });
     }
     connect() {
-        this.whatsAppConection.connect();
+        this.receiver.connect();
     }
 };
 WhatsAppChannel = __decorate([
@@ -55,9 +57,8 @@ WhatsAppChannel = __decorate([
     __metadata("design:paramtypes", [WhatsappChannelConfig,
         ChatResolver,
         UserResolver,
-        WabotEnv,
-        WhatsAppDevConnection,
-        WhatsAppProdConnection])
+        WhatsAppSender,
+        WhatsAppReceiver])
 ], WhatsAppChannel);
 
 export { WhatsAppChannel };