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

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

@@ -0,0 +1,108 @@
+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';
+
+let DeepSeekChatBotAdapter = class DeepSeekChatBotAdapter extends ChatBotAdapter {
+    deepSeek;
+    model;
+    constructor(mindset) {
+        super(mindset);
+        const model = process.env.DEEPSEEK_CHAT_MODEL;
+        const apiKey = process.env.DEEPSEEK_API_KEY;
+        const baseURL = process.env.DEEPSEEK_BASE_URL;
+        this.validateEnvVariables([model, apiKey, baseURL]);
+        this.model = model || 'deepseek-chat';
+        this.deepSeek = new OpenAI({
+            apiKey: apiKey,
+            baseURL: baseURL
+        });
+    }
+    validateEnvVariables(envVariables) {
+        envVariables.forEach((envVariable) => {
+            if (!envVariable) {
+                throw new Error('Missing environment variable');
+            }
+        });
+    }
+    async generateNextChatItem(chatItems) {
+        const systemPrompt = await this.systemPrompt();
+        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 }
+            };
+        });
+        const response = await this.deepSeek.chat.completions.create({
+            model: this.model,
+            messages: [{ role: 'system', content: systemPrompt }, ...this.mapChatItems(chatItems)],
+            tools: tools,
+            tool_choice: 'auto'
+        });
+        let newChatItem;
+        const { tool_calls: responseFunctionCall, content: responseText } = response.choices?.[0]?.message ?? {};
+        if (responseText) {
+            newChatItem = await this.buildBotMessageItem(responseText);
+        }
+        else if (responseFunctionCall && responseFunctionCall[0]?.type == 'function') {
+            newChatItem = await this.buildFunctionCallItem(responseFunctionCall[0].id, responseFunctionCall[0].function.name, responseFunctionCall[0].function.arguments);
+        }
+        else {
+            throw new Error('Not supported DeepSeek Response');
+        }
+        return newChatItem;
+    }
+    mapChatItems(chatItems) {
+        const deepSeekInput = [];
+        for (const item of chatItems) {
+            const itemData = item.getData();
+            if (itemData.type === 'CONNECTION_MESSAGE') {
+                if (!itemData.content.text) {
+                    throw new Error('System message content is empty');
+                }
+                deepSeekInput.push({ role: 'user', content: itemData.content.text });
+            }
+            else if (itemData.type === 'BOT_MESSAGE') {
+                if (!itemData.content.text) {
+                    throw new Error('System message content is empty');
+                }
+                deepSeekInput.push({ role: 'assistant', content: itemData.content.text });
+            }
+            if (itemData.type === 'FUNCTION_CALL') {
+                deepSeekInput.push({
+                    role: 'assistant',
+                    tool_calls: [
+                        {
+                            id: itemData.content.id,
+                            type: 'function',
+                            function: {
+                                name: itemData.content.name,
+                                arguments: JSON.stringify(itemData.content.arguments)
+                            }
+                        }
+                    ]
+                });
+                deepSeekInput.push({
+                    role: 'tool',
+                    tool_call_id: itemData.content.id,
+                    content: itemData.content.result
+                });
+            }
+        }
+        return deepSeekInput;
+    }
+};
+DeepSeekChatBotAdapter = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [MindsetOperator])
+], DeepSeekChatBotAdapter);
+
+export { DeepSeekChatBotAdapter };

package/dist/src/channels/socket-io/@socket.js

@@ -0,0 +1,24 @@
+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';
+
+function socket(config) {
+    return function (target, propertyKey) {
+        const store = container.resolve(ControllerMetadataStore);
+        store.saveChannelMetadata({
+            channelConstructor: SocketChannel,
+            functionName: propertyKey.toString(),
+            controllerConstructor: target.constructor,
+            channelConfig: new SocketChannelConfig(config.channel),
+        });
+    };
+}
+
+export { socket };

package/dist/src/channels/socket-io/SocketChannel.js

@@ -0,0 +1,78 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { SocketChannelConfig } from './SocketChannelConfig.js';
+import { injectable, inject } 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';
+
+var SocketChannel_1;
+let SocketChannel = SocketChannel_1 = class SocketChannel {
+    config;
+    server;
+    chatResolver;
+    userResolver;
+    callBack = null;
+    constructor(config, server, chatResolver, userResolver) {
+        this.config = config;
+        this.server = server;
+        this.chatResolver = chatResolver;
+        this.userResolver = userResolver;
+    }
+    listen(callback) {
+        this.callBack = callback;
+    }
+    connect() {
+        this.server.on('connection', (socket) => {
+            socket.on(this.config.channel, async (message) => {
+                const trimmedInput = message.text.trim();
+                if (!trimmedInput) {
+                    return;
+                }
+                if (!message.chatId || !message.userId || !message.senderName) {
+                    socket.emit(this.config.channel, {
+                        error: 'Invalid message format. chatId, userId, and senderName are required.',
+                    });
+                    return;
+                }
+                const chatConnection = {
+                    id: message.chatId,
+                    chatType: 'PRIVATE',
+                    channelName: SocketChannel_1.name,
+                };
+                const chat = await this.chatResolver.resolve(chatConnection);
+                const userConnection = {
+                    id: message.userId,
+                    channelName: SocketChannel_1.name,
+                };
+                const user = await this.userResolver.resolve(userConnection);
+                if (!this.callBack)
+                    return;
+                this.callBack({
+                    chat,
+                    user,
+                    message: {
+                        chatConnection,
+                        userConnection,
+                        text: trimmedInput,
+                        senderName: message.senderName,
+                    },
+                    reply: (message) => {
+                        socket.emit(this.config.channel, message);
+                    },
+                });
+            });
+        });
+    }
+};
+SocketChannel = SocketChannel_1 = __decorate([
+    injectable(),
+    __param(1, inject(SocketIoApp)),
+    __metadata("design:paramtypes", [SocketChannelConfig, Function, ChatResolver,
+        UserResolver])
+], SocketChannel);
+
+export { SocketChannel };

package/dist/src/channels/socket-io/SocketChannelConfig.js

@@ -0,0 +1,15 @@
+import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../../injection/index.js';
+
+let SocketChannelConfig = class SocketChannelConfig {
+    channel;
+    constructor(channel) {
+        this.channel = channel;
+    }
+};
+SocketChannelConfig = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [String])
+], SocketChannelConfig);
+
+export { SocketChannelConfig };

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

@@ -3,7 +3,7 @@ import { singleton } from '../../injection/index.js';
 import { Logger } from '../../logger/Logger.js';
 import { io } from 'socket.io-client';
 import { WhatsAppConnection } from './WhatsAppConnection.js';
-import { devWhatsappEmitEvent, devWhatsAppListentEvent } from './whatsAppDevSocketContracts.js';
+import { devWhatsappEmitEvent, devWhatsAppListentEvent } from './WhatsAppDevSocketContracts.js';
 
 let WhatsAppDevConnection = class WhatsAppDevConnection extends WhatsAppConnection {
     devProxy;
@@ -24,6 +24,14 @@ let WhatsAppDevConnection = class WhatsAppDevConnection extends WhatsAppConnecti
         };
         await this.devProxySocket.emitWithAck(devWhatsappEmitEvent.DEV_SEND_WHATSAPP, req);
     }
+    async sendWhatsAppTemplate(businessNumber, to, templateMessage) {
+        const req = {
+            from: businessNumber,
+            to,
+            message: templateMessage,
+        };
+        await this.devProxySocket.emitWithAck(devWhatsappEmitEvent.DEV_SEND_WHATSAPP_TEMPLATE, req);
+    }
     connect() {
         if (this.connected) {
             return;

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

@@ -4,6 +4,7 @@ const devWhatsAppListentEvent = {
 const devWhatsappEmitEvent = {
     DEV_CONNECTION: 'dev-connection',
     DEV_SEND_WHATSAPP: 'dev-send-whatsapp',
+    DEV_SEND_WHATSAPP_TEMPLATE: 'dev-send-whatsapp-template',
 };
 
 export { devWhatsAppListentEvent, devWhatsappEmitEvent };

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

@@ -23,6 +23,9 @@ let WhatsAppProdConnection = class WhatsAppProdConnection {
     sendWhatsApp(businessNumber, to, replyMessage) {
         throw new Error('Method not implemented.');
     }
+    sendWhatsAppTemplate(businessNumber, to, templateMessage) {
+        throw new Error('Method not implemented.');
+    }
     connect() {
         throw new Error('Method not implemented.');
     }

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

@@ -0,0 +1,23 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from 'tsyringe';
+
+let WhatsAppSender = class WhatsAppSender {
+    wabotEnv;
+    whatsAppConection;
+    constructor(wabotEnv, devConnection, prodConnection) {
+        this.wabotEnv = wabotEnv;
+        this.whatsAppConection = this.wabotEnv.isProduction() ? prodConnection : devConnection;
+    }
+    async send(businessNumber, to, message) {
+        this.whatsAppConection.sendWhatsApp(businessNumber, to, message);
+    }
+    async sendTemplate(businessNumber, to, templateMessage) {
+        this.whatsAppConection.sendWhatsAppTemplate(businessNumber, to, templateMessage);
+    }
+};
+WhatsAppSender = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Function, Function, Function])
+], WhatsAppSender);
+
+export { WhatsAppSender };

package/dist/src/index.d.ts

@@ -3,13 +3,14 @@ import DependencyContainer, { PreResolutionInterceptorCallback, PostResolutionIn
 import InterceptionOptions from 'tsyringe/dist/typings/types/interceptor-options';
 import { Express } from 'express';
 export { Express } from 'express';
+import { Server } from 'socket.io';
+export { Server as SocketIo } from 'socket.io';
 import * as tsyringe from 'tsyringe';
 import { DependencyContainer as DependencyContainer$1 } from 'tsyringe';
 export { DependencyContainer } from 'tsyringe';
 import { Pool } from 'pg';
 import { Database } from 'sqlite';
 import sqlite3 from 'sqlite3';
-export { Server as SocketIo } from 'socket.io';
 
 interface IMindsetFunctionConfig {
     description: string;
@@ -231,6 +232,7 @@ declare function isOptional(): PropertyDecorator;
 
 interface IParamConfig {
     name?: string;
+    optional?: boolean;
     description: string;
 }
 
@@ -375,6 +377,15 @@ declare class OpenaiChatBotAdapter extends ChatBotAdapter {
     private mapChatItems;
 }
 
+declare class DeepSeekChatBotAdapter extends ChatBotAdapter {
+    private deepSeek;
+    private model;
+    constructor(mindset: MindsetOperator);
+    validateEnvVariables(envVariables: (string | undefined)[]): void;
+    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
+    private mapChatItems;
+}
+
 declare function cmd(): (target: object, propertyKey: string | symbol) => void;
 
 declare class ChatResolver {
@@ -471,6 +482,36 @@ declare class WhatsappChannelConfig implements IWhatsappChannelConfig {
 
 declare function whatsapp(config: IWhatsappChannelConfig): (target: object, propertyKey: string | symbol) => void;
 
+type IWhatsAppTemplateParameter = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'currency';
+    currency: {
+        fallback_value: string;
+        code: string;
+        amount_1000: number;
+    };
+} | {
+    type: 'date_time';
+    date_time: {
+        fallback_value: string;
+    };
+};
+interface IWhatsAppTemplateMessage {
+    templateName: string;
+    languageCode: string;
+    parameters: IWhatsAppTemplateParameter[];
+}
+
+type IWhatsAppMessageListener = (message: IConnectionChatMessage) => Promise<void>;
+interface IWhatsAppConnection {
+    listenMessage(businessNumber: string, listener: IWhatsAppMessageListener): void;
+    sendWhatsApp(businessNumber: string, to: string, message: IChatMessage): Promise<void>;
+    sendWhatsAppTemplate(businessNumber: string, to: string, templateMessage: IWhatsAppTemplateMessage): Promise<void>;
+    connect(): void;
+}
+
 interface IWhatsAppWebhookPayload {
     object: 'whatsapp_business_account';
     entry: IEntry[];
@@ -531,13 +572,6 @@ declare class WabotEnv {
     isProduction(): boolean;
 }
 
-type IWhatsAppMessageListener = (message: IConnectionChatMessage) => Promise<void>;
-interface IWhatsAppConnection {
-    listenMessage(businessNumber: string, listener: IWhatsAppMessageListener): void;
-    sendWhatsApp(businessNumber: string, to: string, replyMessage: IChatMessage): Promise<void>;
-    connect(): void;
-}
-
 declare class Logger {
     private debuggers;
     constructor(name: string);
@@ -556,6 +590,7 @@ declare abstract class WhatsAppConnection implements IWhatsAppConnection {
     constructor(logger: Logger);
     abstract sendWhatsApp(businessNumber: string, to: string, chatMessage: IChatMessage): Promise<void>;
     abstract connect(): void;
+    abstract sendWhatsAppTemplate(businessNumber: string, to: string, templateMessage: IWhatsAppTemplateMessage): Promise<void>;
     listenMessage(businessNumber: string, listener: IWhatsAppMessageListener): void;
     protected handlePayload(payload: IWhatsAppWebhookPayload): Promise<void>;
     private emmitMessage;
@@ -568,6 +603,7 @@ declare class WhatsAppDevConnection extends WhatsAppConnection implements IWhats
     private connected;
     constructor();
     sendWhatsApp(businessNumber: string, to: string, chatMessage: IChatMessage): Promise<void>;
+    sendWhatsAppTemplate(businessNumber: string, to: string, templateMessage: IWhatsAppTemplateMessage): Promise<void>;
     connect(): void;
 }
 
@@ -576,6 +612,7 @@ declare class WhatsAppProdConnection implements IWhatsAppConnection {
     constructor(express: Express);
     listenMessage(businessNumber: string, listener: IWhatsAppMessageListener): void;
     sendWhatsApp(businessNumber: string, to: string, replyMessage: IChatMessage): Promise<void>;
+    sendWhatsAppTemplate(businessNumber: string, to: string, templateMessage: IWhatsAppTemplateMessage): Promise<void>;
     connect(): void;
 }
 
@@ -597,6 +634,7 @@ declare const devWhatsAppListentEvent: {
 declare const devWhatsappEmitEvent: {
     readonly DEV_CONNECTION: "dev-connection";
     readonly DEV_SEND_WHATSAPP: "dev-send-whatsapp";
+    readonly DEV_SEND_WHATSAPP_TEMPLATE: "dev-send-whatsapp-template";
 };
 interface IDevConnectionRequest {
     token: string;
@@ -606,6 +644,41 @@ interface IDevSendWhatsappRequest {
     to: string;
     message: IChatMessage;
 }
+interface IDevSendWhatsappTemplateRequest {
+    from: string;
+    to: string;
+    message: IWhatsAppTemplateMessage;
+}
+
+declare class WhatsAppSender {
+    private wabotEnv;
+    private whatsAppConection;
+    constructor(wabotEnv: WabotEnv, devConnection: WhatsAppDevConnection, prodConnection: WhatsAppProdConnection);
+    send(businessNumber: string, to: string, message: IChatMessage): Promise<void>;
+    sendTemplate(businessNumber: string, to: string, templateMessage: IWhatsAppTemplateMessage): Promise<void>;
+}
+
+interface ISocketChannelConfig {
+    channel: string;
+}
+
+declare class SocketChannelConfig implements ISocketChannelConfig {
+    channel: string;
+    constructor(channel: string);
+}
+
+declare function socket(config: SocketChannelConfig): (target: object, propertyKey: string | symbol) => void;
+
+declare class SocketChannel implements IChatChannel {
+    private config;
+    private server;
+    private chatResolver;
+    private userResolver;
+    private callBack;
+    constructor(config: SocketChannelConfig, server: Server, chatResolver: ChatResolver, userResolver: UserResolver);
+    listen(callback: (message: IReceivedMessage) => void): void;
+    connect(): void;
+}
 
 declare function prepareChatContainer(container: DependencyContainer$1, context: IMessageContext, mindsetCtor?: IConstructor<IMindset>): Promise<DependencyContainer$1>;
 
@@ -828,4 +901,4 @@ declare class RamChatRepository implements IChatRepository {
     private getMemory;
 }
 
-export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, EmailService, ExpressApp, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type IConnectionChatMessage, type IConstructor, type ICrudRepository, type IDevConnectionRequest, type IDevSendWhatsappRequest, type IEmailService, type IMessageContext, type IMessageMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistent, type IPgRepositoryConfig, type IReceivedMessage, type IReceivedMessageItem, type IReversibleMapper, type ISendEmailRequest, type IServerConfig, type IServerProvider, type ISqliteRecord, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IWabotEnvType, type IWhatsAppContact, type IWhatsAppMessage, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, SendOneTimePasswordRequest, SocketIoApp, SqliteChatMemory, SqliteChatRepository, SqliteCrudRepository, SqlitePersistentMapper, SqliteUserRepository, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, WabotEnv, WhatsAppChannel, WhatsappChannelConfig, chatBot, chatController, cmd, container, devWhatsAppListentEvent, devWhatsappEmitEvent, inject, injectable, isOptional, mindset, mindsetFunction, mindsetModule, param, prepareChatContainer, runChannel, runServer, singleton, sqliteMapperFor, telegram, whatsapp };
+export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, DeepSeekChatBotAdapter, EmailService, ExpressApp, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type IConnectionChatMessage, type IConstructor, type ICrudRepository, type IDevConnectionRequest, type IDevSendWhatsappRequest, type IDevSendWhatsappTemplateRequest, type IEmailService, type IMessageContext, type IMessageMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistent, type IPgRepositoryConfig, type IReceivedMessage, type IReceivedMessageItem, type IReversibleMapper, type ISendEmailRequest, type IServerConfig, type IServerProvider, type ISqliteRecord, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IWabotEnvType, type IWhatsAppConnection, type IWhatsAppContact, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketIoApp, SqliteChatMemory, SqliteChatRepository, SqliteCrudRepository, SqlitePersistentMapper, SqliteUserRepository, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, WabotEnv, WhatsAppChannel, WhatsAppConnection, WhatsAppDevConnection, WhatsAppProdConnection, WhatsAppSender, WhatsappChannelConfig, chatBot, chatController, cmd, container, devWhatsAppListentEvent, devWhatsappEmitEvent, inject, injectable, isOptional, mindset, mindsetFunction, mindsetModule, param, prepareChatContainer, runChannel, runServer, singleton, socket, sqliteMapperFor, telegram, whatsapp };

package/dist/src/index.js

@@ -1,4 +1,5 @@
 export { OpenaiChatBotAdapter } from './ai/openia/OpenaiChatBotAdapter.js';
+export { DeepSeekChatBotAdapter } from './ai/deepseek/DeepSeekChatBotAdapter.js';
 export { cmd } from './channels/cmd/@cmd.js';
 export { CmdChannel } from './channels/cmd/CmdChannel.js';
 export { telegram } from './channels/telegram/@telegram.js';
@@ -7,7 +8,14 @@ export { TelegramChannel } from './channels/telegram/TelegramChannel.js';
 export { whatsapp } from './channels/whatsapp/@whatsapp.js';
 export { WhatsAppChannel } from './channels/whatsapp/WhatsAppChannel.js';
 export { WhatsappChannelConfig } from './channels/whatsapp/WhatsAppChannelConfig.js';
-export { devWhatsAppListentEvent, devWhatsappEmitEvent } from './channels/whatsapp/whatsAppDevSocketContracts.js';
+export { WhatsAppConnection } from './channels/whatsapp/WhatsAppConnection.js';
+export { WhatsAppDevConnection } from './channels/whatsapp/WhatsAppDevConnection.js';
+export { devWhatsAppListentEvent, devWhatsappEmitEvent } from './channels/whatsapp/WhatsAppDevSocketContracts.js';
+export { WhatsAppProdConnection } from './channels/whatsapp/WhatsAppProdConnection.js';
+export { WhatsAppSender } from './channels/whatsapp/WhatsAppSender.js';
+export { socket } from './channels/socket-io/@socket.js';
+export { SocketChannel } from './channels/socket-io/SocketChannel.js';
+export { SocketChannelConfig } from './channels/socket-io/SocketChannelConfig.js';
 export { chatBot } from './chatbot/metadata/@chatBot.js';
 export { ChatBotMetadataStore } from './chatbot/metadata/ChatBotMetadataStore.js';
 export { mindsetFunction } from './mindset/metadata/functions/@mindsetFunction.js';

package/dist/src/mindset/MindsetOperator.js

@@ -62,7 +62,7 @@ let MindsetOperator = class MindsetOperator {
                     ...prev,
                     [param.name]: this.toolParam(param),
                 }), {}),
-                required: fn.params.map((param) => param.name),
+                required: fn.params.filter((param) => !param.config.optional).map((param) => param.name)
             },
         };
     }

package/package.json

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