@wabot-dev/framework 0.1.0-beta.3 → 0.1.0-beta.30

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

@@ -0,0 +1,26 @@
+import { __decorate, __metadata } from 'tslib';
+import { Pool } from 'pg';
+import { singleton } from '../../../core/injection/index.js';
+import { PgCrudRepository } from '../../repository/pg/PgCrudRepository.js';
+import '../../../feature/async/CommandMetadataStore.js';
+import '../../../feature/async/Async.js';
+import { Job } from '../../../feature/async/Job.js';
+import '../../../feature/async/JobRepository.js';
+import '../../../feature/async/JobRunner.js';
+import '../../../feature/async/JobsEventsHub.js';
+
+let PgJobRepository = class PgJobRepository extends PgCrudRepository {
+    constructor(pool) {
+        super(pool, {
+            schema: 'wabot',
+            table: 'job',
+            constructor: Job,
+        });
+    }
+};
+PgJobRepository = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Pool])
+], PgJobRepository);
+
+export { PgJobRepository };

package/dist/src/addon/chat-bot/claude/ClaudeChatBotAdapter.js

@@ -0,0 +1,107 @@
+// import { injectable } from '@/injection'
+// import { Anthropic } from '@anthropic-ai/sdk'
+// import { ChatBotAdapter } from '@/chatbot'
+// import type { ChatItem } from '@/core'
+// import { MindsetOperator } from '@/mindset'
+// import { Logger } from '@/logger'
+class DummyClaudeChatBotAdapter {
+}
+// @injectable()
+// export class ClaudeChatBotAdapter extends ChatBotAdapter {
+//   private anthropic: Anthropic
+//   private model: string
+//   private logger = new Logger('wabot:claude-chat-bot-adapter')
+//   constructor(mindset: MindsetOperator) {
+//     super(mindset)
+//     const apiKey = process.env.CLAUDE_API_KEY
+//     if (!apiKey) {
+//       throw new Error(`CLAUDE_API_KEY env variable is required`)
+//     }
+//     const model = process.env.CLAUDE_CHAT_MODEL
+//     if (!model) {
+//       throw new Error(`CLAUDE_CHAT_MODEL env variable is required`)
+//     }
+//     this.anthropic = new Anthropic({ apiKey })
+//     this.model = model
+//   }
+//   override async generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem> {
+//     const systemPrompt = await this.systemPrompt()
+//     const tools = (await this.mindset.allFunctionsDescriptors()).map((fn) => {
+//       return {
+//         name: fn.name,
+//         description: fn.description,
+//         input_schema: {
+//           ...fn.parameters,
+//           type: 'object' as const
+//         }
+//       }
+//     })
+//     const messages = this.mapChatItems(chatItems)
+//     const request = {
+//       model: this.model,
+//       max_tokens: 4096,
+//       system: systemPrompt,
+//       messages,
+//       tools: tools.length > 0 ? tools : undefined,
+//     }
+//     this.logger.debug(`Call Claude API with Request: ${JSON.stringify(request)}`)
+//     const response = await this.anthropic.messages.create(request)
+//     let newChatItem: ChatItem
+//     const content = response.content[0]
+//     if (content.type === 'text') {
+//       newChatItem = await this.buildBotMessageItem(content.text)
+//     } else if (content.type === 'tool_use') {
+//       newChatItem = await this.buildFunctionCallItem(
+//         content.id,
+//         content.name,
+//         JSON.stringify(content.input),
+//       )
+//     } else {
+//       throw new Error('Not supported Claude Response')
+//     }
+//     return newChatItem
+//   }
+//   private mapChatItems(chatItems: ChatItem[]): Anthropic.Messages.MessageParam[] {
+//     // const messages: Anthropic.Messages.MessageParam[] = []
+//     // for (const item of chatItems) {
+//     //   const itemData = item.getData()
+//     //   if (itemData.type === 'CONNECTION_MESSAGE') {
+//     //     if (!itemData.content.text) {
+//     //       throw new Error('User message content is empty')
+//     //     }
+//     //     messages.push({ role: 'user', content: itemData.content.text })
+//     //   } else if (itemData.type === 'BOT_MESSAGE') {
+//     //     if (!itemData.content.text) {
+//     //       throw new Error('Assistant message content is empty')
+//     //     }
+//     //     messages.push({ role: 'assistant', content: itemData.content.text })
+//     //   } else if (itemData.type === 'FUNCTION_CALL') {
+//     //     messages.push({
+//     //       role: 'assistant',
+//     //       content: [
+//     //         {
+//     //           type: 'tool_use',
+//     //           id: itemData.content.id,
+//     //           name: itemData.content.name,
+//     //           input: JSON.parse(itemData.content.arguments || '{}')
+//     //         }
+//     //       ]
+//     //     })
+//     //     messages.push({
+//     //       role: 'user',
+//     //       content: [
+//     //         {
+//     //           type: 'tool_result',
+//     //           tool_use_id: itemData.content.id,
+//     //           content: itemData.content.result || 'No result'
+//     //         }
+//     //       ]
+//     //     })
+//     //   }
+//     // }
+//     // return messages
+//     return []
+//   }
+// }
+
+export { DummyClaudeChatBotAdapter };

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

@@ -0,0 +1,103 @@
+// import { injectable } from '@/injection'
+// import { OpenAI } from 'openai'
+// import { ChatBotAdapter } from '@/chatbot'
+// import type { ChatItem } from '@/core'
+// import { MindsetOperator } from '@/mindset'
+class DummyDeepSeekChatBotAdapter {
+}
+// @injectable()
+// export class DeepSeekChatBotAdapter extends ChatBotAdapter {
+//   private deepSeek: OpenAI
+//   private model: string
+//   constructor(mindset: MindsetOperator) {
+//     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: (string | undefined)[]): void {
+//     envVariables.forEach((envVariable) => {
+//       if (!envVariable) {
+//         throw new Error('Missing environment variable')
+//       }
+//     })
+//   }
+//   override async generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem> {
+//     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 },
+//       } as const
+//     })
+//     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: ChatItem
+//     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
+//   }
+//   private mapChatItems(chatItems: ChatItem[]): OpenAI.Chat.ChatCompletionMessageParam[] {
+//     // const deepSeekInput: OpenAI.Chat.ChatCompletionMessageParam[] = []
+//     // 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 ?? 'No result',
+//     //     })
+//     //   }
+//     // }
+//     // return deepSeekInput
+//     return []
+//   }
+// }
+
+export { DummyDeepSeekChatBotAdapter };

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

@@ -0,0 +1,101 @@
+import { Logger } from '../../../core/logger/Logger.js';
+import { OpenAI } from 'openai';
+
+class OpenaiChatAdapter {
+    openai = new OpenAI();
+    logger = new Logger('wabot:openai-chat-adapter');
+    async nextItem(req) {
+        const openIaInput = [];
+        openIaInput.push({ role: 'system', content: req.systemPrompt });
+        openIaInput.push(...this.mapChatItems(req.prevItems));
+        const tools = req.tools.map((x) => this.mapTool(x));
+        const response = await this.openai.responses.create({
+            model: req.model,
+            input: openIaInput,
+            tools,
+        });
+        return this.mapResponse(response);
+    }
+    mapChatItems(chatItems) {
+        const openIaInput = [];
+        for (const chatItem of chatItems) {
+            switch (chatItem.type) {
+                case 'humanMessage':
+                    openIaInput.push(this.mapConectionMessage(chatItem.humanMessage));
+                    break;
+                case 'botMessage':
+                    openIaInput.push(this.mapBotMessage(chatItem.botMessage));
+                    break;
+                case 'functionCall':
+                    openIaInput.push(...this.mapFunctionCall(chatItem.functionCall));
+                    break;
+            }
+        }
+        return openIaInput;
+    }
+    mapConectionMessage(item) {
+        if (!item.text) {
+            throw new Error('System message content is empty');
+        }
+        return { role: 'user', content: item.text };
+    }
+    mapBotMessage(item) {
+        if (!item.text) {
+            throw new Error('System message content is empty');
+        }
+        return { role: 'assistant', content: item.text };
+    }
+    mapFunctionCall(item) {
+        return [
+            {
+                type: 'function_call',
+                call_id: item.id,
+                name: item.name,
+                arguments: JSON.stringify(item.arguments),
+            },
+            {
+                type: 'function_call_output',
+                call_id: item.id,
+                output: item.result ?? 'Not result',
+            },
+        ];
+    }
+    mapTool(tool) {
+        return {
+            type: 'function',
+            name: tool.name,
+            description: tool.description,
+            parameters: {
+                type: 'object',
+                properties: tool.parameters.reduce((prev, param) => ({
+                    ...prev,
+                    [param.name]: { type: param.type, description: param.description },
+                }), {}),
+                required: tool.parameters.map((param) => param.name),
+            },
+            strict: true,
+        };
+    }
+    mapResponse(response) {
+        let newItem;
+        if (response.output_text) {
+            newItem = { type: 'botMessage', botMessage: { text: response.output_text } };
+        }
+        else if (response.output && response.output[0]?.type == 'function_call') {
+            newItem = {
+                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');
+        }
+        return newItem;
+    }
+}
+
+export { OpenaiChatAdapter };

package/dist/src/{pre-made/repository/chat → addon/chat-bot}/pg/PgChatMemory.js

@@ -1,7 +1,8 @@
-import '../../../../core/chat/repository/IChatRepository.js';
-import { ChatItem } from '../../../../core/chat/ChatItem.js';
-import '../../../../core/user/IUserRepository.js';
-import { PgCrudRepository } from '../../../../repository/pg/PgCrudRepository.js';
+import { PgCrudRepository } from '../../repository/pg/PgCrudRepository.js';
+import { ChatItem } from '../../../feature/chat-bot/ChatItem.js';
+import '../../../core/injection/index.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 
 class PgChatMemory extends PgCrudRepository {
     chatId;

package/dist/src/{pre-made/repository/chat → addon/chat-bot}/pg/PgChatRepository.js

@@ -1,11 +1,11 @@
 import { __decorate, __metadata } from 'tslib';
-import '../../../../core/chat/repository/IChatRepository.js';
-import { Chat } from '../../../../core/chat/Chat.js';
-import '../../../../core/user/IUserRepository.js';
-import { singleton } from '../../../../injection/index.js';
 import { Pool } from 'pg';
 import { PgChatMemory } from './PgChatMemory.js';
-import { PgCrudRepository } from '../../../../repository/pg/PgCrudRepository.js';
+import { singleton } from '../../../core/injection/index.js';
+import { PgCrudRepository } from '../../repository/pg/PgCrudRepository.js';
+import { Chat } from '../../../feature/chat-bot/Chat.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 
 let PgChatRepository = class PgChatRepository extends PgCrudRepository {
     constructor(pool) {

package/dist/src/{pre-made/repository/chat → addon/chat-bot}/ram/RamChatRepository.js

@@ -1,7 +1,7 @@
 import { __decorate } from 'tslib';
 import { v4 } from 'uuid';
 import { RamChatMemory } from './RamChatMemory.js';
-import { singleton } from '../../../../injection/index.js';
+import { singleton } from '../../../core/injection/index.js';
 
 let RamChatRepository = class RamChatRepository {
     items = [];
@@ -16,7 +16,7 @@ let RamChatRepository = class RamChatRepository {
         this.items.push(chat);
         const memory = {
             memory: new RamChatMemory(),
-            chatId: chat.getId(),
+            chatId: chat.id,
         };
         this.memories.push(memory);
     }

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

@@ -0,0 +1,22 @@
+import { container } from '../../../core/injection/index.js';
+import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../feature/chat-controller/ChatResolver.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import 'reflect-metadata';
+import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
+import '../../../feature/mindset/MindsetOperator.js';
+import { CmdChannel } from './CmdChannel.js';
+
+function cmd() {
+    return function (target, propertyKey) {
+        const store = container.resolve(ControllerMetadataStore);
+        store.saveChannelMetadata({
+            channelConstructor: CmdChannel,
+            functionName: propertyKey.toString(),
+            controllerConstructor: target.constructor,
+        });
+    };
+}
+
+export { cmd };

package/dist/src/{channels → addon/chat-controller}/cmd/CmdChannel.js

@@ -1,25 +1,15 @@
-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 '../../controller/metadata/ControllerMetadataStore.js';
+import { __decorate } from 'tslib';
+import { injectable } from '../../../core/injection/index.js';
 import * as readline from 'readline';
 
 var CmdChannel_1;
 const chatId = 'cmd';
-const userId = 'cmd';
 let CmdChannel = CmdChannel_1 = class CmdChannel {
-    chatResolver;
-    userResolver;
     rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
     });
     callBack = null;
-    constructor(chatResolver, userResolver) {
-        this.chatResolver = chatResolver;
-        this.userResolver = userResolver;
-    }
     listen(callback) {
         this.callBack = callback;
     }
@@ -39,22 +29,12 @@ let CmdChannel = CmdChannel_1 = class CmdChannel {
                 chatType: 'PRIVATE',
                 channelName: CmdChannel_1.name,
             };
-            const chat = await this.chatResolver.resolve(chatConnection);
-            const userConnection = {
-                id: userId,
-                channelName: CmdChannel_1.name,
-            };
-            const user = await this.userResolver.resolve(userConnection);
             if (!this.callBack)
                 return;
             this.callBack({
-                chat,
-                user,
+                chatConnection,
                 message: {
-                    chatConnection,
-                    userConnection,
                     text: trimmedInput,
-                    senderName: 'cmd',
                 },
                 reply: (message) => {
                     console.log(`\n[${message.senderName}]: ${message.text}\n`);
@@ -65,9 +45,7 @@ let CmdChannel = CmdChannel_1 = class CmdChannel {
     }
 };
 CmdChannel = CmdChannel_1 = __decorate([
-    injectable(),
-    __metadata("design:paramtypes", [ChatResolver,
-        UserResolver])
+    injectable()
 ], CmdChannel);
 
 export { CmdChannel };

package/dist/src/{channels → addon/chat-controller}/socket/@socket.js

@@ -1,7 +1,11 @@
-import '../../controller/channel/ChatResolver.js';
-import '../../controller/channel/UserResolver.js';
-import { container } from '../../injection/index.js';
-import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
+import { container } from '../../../core/injection/index.js';
+import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../feature/chat-controller/ChatResolver.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import 'reflect-metadata';
+import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
+import '../../../feature/mindset/MindsetOperator.js';
 import { SocketChannel } from './SocketChannel.js';
 import { SocketChannelConfig } from './SocketChannelConfig.js';
 

package/dist/src/{channels → addon/chat-controller}/socket/SocketChannel.js

@@ -1,24 +1,17 @@
 import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../../../core/injection/index.js';
+import { SocketServerProvider } from '../../../feature/socket/SocketServerProvider.js';
 import { SocketChannelConfig } from './SocketChannelConfig.js';
-import { injectable } from '../../injection/index.js';
-import { ChatResolver } from '../../controller/channel/ChatResolver.js';
-import { UserResolver } from '../../controller/channel/UserResolver.js';
-import '../../controller/metadata/ControllerMetadataStore.js';
-import { SocketServerProvider } from './SocketServerProvider.js';
 
 var SocketChannel_1;
 let SocketChannel = SocketChannel_1 = class SocketChannel {
     config;
     socketServerProvider;
-    chatResolver;
-    userResolver;
     callBack = null;
     server;
-    constructor(config, socketServerProvider, chatResolver, userResolver) {
+    constructor(config, socketServerProvider) {
         this.config = config;
         this.socketServerProvider = socketServerProvider;
-        this.chatResolver = chatResolver;
-        this.userResolver = userResolver;
         this.server = this.socketServerProvider.getSocketServer();
     }
     listen(callback) {
@@ -42,20 +35,11 @@ let SocketChannel = SocketChannel_1 = class SocketChannel {
                     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,
+                    chatConnection,
                     message: {
-                        chatConnection,
-                        userConnection,
                         text: trimmedInput,
                         senderName: message.senderName,
                     },
@@ -71,9 +55,7 @@ let SocketChannel = SocketChannel_1 = class SocketChannel {
 SocketChannel = SocketChannel_1 = __decorate([
     injectable(),
     __metadata("design:paramtypes", [SocketChannelConfig,
-        SocketServerProvider,
-        ChatResolver,
-        UserResolver])
+        SocketServerProvider])
 ], SocketChannel);
 
 export { SocketChannel };

package/dist/src/{channels → addon/chat-controller}/socket/SocketChannelConfig.js

@@ -1,5 +1,5 @@
 import { __decorate, __metadata } from 'tslib';
-import { injectable } from '../../injection/index.js';
+import { injectable } from '../../../core/injection/index.js';
 
 let SocketChannelConfig = class SocketChannelConfig {
     channel;

package/dist/src/{channels → addon/chat-controller}/telegram/@telegram.js

@@ -1,7 +1,11 @@
-import { container } from '../../injection/index.js';
-import '../../controller/channel/ChatResolver.js';
-import '../../controller/channel/UserResolver.js';
-import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
+import { container } from '../../../core/injection/index.js';
+import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../feature/chat-controller/ChatResolver.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import 'reflect-metadata';
+import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
+import '../../../feature/mindset/MindsetOperator.js';
 import { TelegramChannel } from './TelegramChannel.js';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 

package/dist/src/{channels → addon/chat-controller}/telegram/TelegramChannel.js

@@ -1,21 +1,14 @@
 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 '../../controller/metadata/ControllerMetadataStore.js';
 import { Bot } from 'grammy';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
+import { injectable } from '../../../core/injection/index.js';
 
 var TelegramChannel_1;
 let TelegramChannel = TelegramChannel_1 = class TelegramChannel {
     config;
-    chatResolver;
-    userResolver;
     bot;
-    constructor(config, chatResolver, userResolver) {
+    constructor(config) {
         this.config = config;
-        this.chatResolver = chatResolver;
-        this.userResolver = userResolver;
         this.bot = new Bot(this.config.botToken);
     }
     listen(callback) {
@@ -28,18 +21,9 @@ let TelegramChannel = TelegramChannel_1 = class TelegramChannel {
                 chatType: ctx.message.chat.type === 'private' ? 'PRIVATE' : 'GROUP',
                 channelName: TelegramChannel_1.name,
             };
-            const chat = await this.chatResolver.resolve(chatConnection);
-            const userConnection = {
-                id: ctx.from.id.toString(),
-                channelName: TelegramChannel_1.name,
-            };
-            const user = await this.userResolver.resolve(userConnection);
             callback({
-                chat,
-                user,
+                chatConnection,
                 message: {
-                    chatConnection,
-                    userConnection,
                     senderName: ctx.from.first_name,
                     text: ctx.message.text,
                 },
@@ -55,9 +39,7 @@ let TelegramChannel = TelegramChannel_1 = class TelegramChannel {
 };
 TelegramChannel = TelegramChannel_1 = __decorate([
     injectable(),
-    __metadata("design:paramtypes", [TelegramChannelConfig,
-        ChatResolver,
-        UserResolver])
+    __metadata("design:paramtypes", [TelegramChannelConfig])
 ], TelegramChannel);
 
 export { TelegramChannel };

package/dist/src/{channels → addon/chat-controller}/whatsapp/@whatsapp.js

@@ -1,8 +1,12 @@
-import { container } from '../../injection/index.js';
+import { container } from '../../../core/injection/index.js';
 import { WhatsappChannelConfig } from './WhatsAppChannelConfig.js';
-import '../../controller/channel/ChatResolver.js';
-import '../../controller/channel/UserResolver.js';
-import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
+import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../feature/chat-controller/ChatResolver.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import 'reflect-metadata';
+import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
+import '../../../feature/mindset/MindsetOperator.js';
 import { WhatsAppChannel } from './WhatsAppChannel.js';
 
 function whatsapp(config) {