@futdevpro/nts-dynamo 1.14.24 → 1.14.27

package/src/_modules/bot/_modules/teams-bot/_services/{teb-provider.service.ts → teb-messaging-provider.service.ts}

@@ -1,27 +1,27 @@
-import { DyNTS_Bot_Provider, DyNTS_Bot_Provider_Config } from '../../../_models/bot-provider.interface';
+import { DyNTS_Bot_MessagingProvider, DyNTS_Bot_MessagingProvider_Config } from '../../../_models/bot-messaging-provider.interface';
 import { DyNTS_Bot_LastMessageDate } from '../../../_models/bot-last-message-date.interface';
 import { DyNTS_Bot_LastMentionDate } from '../../../_models/bot-last-mention-date.interface';
-import { DyNTS_Bot_Provider_Type } from '../../../_enums/bot-provider.enum';
+import { DyNTS_Bot_MessageProvider_Type } from '../../../_enums/bot-message-provider.enum';
 import { DyNTS_TeB_Message, DyNTS_TeB_Channel, DyNTS_TeB_User } from '../_models/teb-platform.types';
 
-export class DyNTS_TeB_Provider implements DyNTS_Bot_Provider<
+export class DyNTS_TeB_MessagingProvider implements DyNTS_Bot_MessagingProvider<
   DyNTS_TeB_Channel,
   DyNTS_TeB_Message,
   DyNTS_TeB_User
 > {
   private isInitialized: boolean = false;
-  private config: DyNTS_Bot_Provider_Config;
+  private config: DyNTS_Bot_MessagingProvider_Config;
   
   // Event handlers
   private messageHandlers: Array<(message: DyNTS_TeB_Message, issuer: string) => void> = [];
   private readyHandlers: Array<() => void> = [];
   private errorHandlers: Array<(error: Error) => void> = [];
 
-  async initialize(config: DyNTS_Bot_Provider_Config): Promise<void> {
+  async initialize(config: DyNTS_Bot_MessagingProvider_Config): Promise<void> {
     this.config = config;
     
-    if (config.provider !== DyNTS_Bot_Provider_Type.teams) {
-      throw new Error(`Invalid provider type: ${config.provider}. Expected 'teams'`);
+    if (config.messageProvider !== DyNTS_Bot_MessageProvider_Type.teams) {
+      throw new Error(`Invalid provider type: ${config.messageProvider}. Expected 'teams'`);
     }
 
     if (!config.teams) {
@@ -146,6 +146,10 @@ export class DyNTS_TeB_Provider implements DyNTS_Bot_Provider<
     return 'teams';
   }
 
+  getProviderId(): string {
+    return this.config?.providerId || this.getProviderName();
+  }
+
   isReady(): boolean {
     return this.isInitialized;
   }

package/src/_modules/bot/_modules/teams-bot/index.ts

@@ -8,7 +8,7 @@
 export * from './_models/teb-platform.types';
 
 // SERVICES
-export * from './_services/teb-provider.service';
+export * from './_services/teb-messaging-provider.service';
 
 // COLLECTIONS
 export * from './_collections/teb-operations.util';

package/src/_modules/bot/_services/bot-commands.control-service.ts

@@ -7,28 +7,29 @@ import { DyNTS_Bot_Message } from '../_models/bot-message.interface';
 import { DyNTS_Bot_Global_Settings } from '../_models/bot-global-settings.interface';
 import { DyNTS_Bot_User } from '../_models/bot-user.interface';
 import { DyNTS_Bot_Channel } from '../_models/bot-channel.interface';
-import { DyNTS_Bot_Provider, DyNTS_Bot_Provider_Config } from '../_models/bot-provider.interface';
+import { DyNTS_Bot_MessagingProvider, DyNTS_Bot_MessagingProvider_Config } from '../_models/bot-messaging-provider.interface';
+import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface';
 
 export abstract class DyNTS_Bot_Commands_ControlService<
-  T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
-  T_PlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
-  T_PlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
-  T_PlatformProvider extends DyNTS_Bot_Provider<
-    T_PlatformChannel, 
-    T_PlatformMessage, 
-    T_PlatformUser
-  > = DyNTS_Bot_Provider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser>
+  T_MessagingPlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
+  T_MessagingPlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
+  T_MessagingPlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
+  T_MessagingPlatformProvider extends DyNTS_Bot_MessagingProvider<
+    T_MessagingPlatformChannel, 
+    T_MessagingPlatformMessage, 
+    T_MessagingPlatformUser
+  > = DyNTS_Bot_MessagingProvider<T_MessagingPlatformChannel, T_MessagingPlatformMessage, T_MessagingPlatformUser>
 > extends DyNTS_SingletonService {
 
   static getInstance<T_PlatformMessage extends DyNTS_Bot_Message<any>>(): DyNTS_Bot_Commands_ControlService<T_PlatformMessage> {
     return DyNTS_Bot_Commands_ControlService.getSingletonInstance();
   }
 
-  protected abstract getMainBotControlService(): DyNTS_Bot_Main_ControlService<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_PlatformProvider>;
-  protected readonly mainBot_CS: DyNTS_Bot_Main_ControlService<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_PlatformProvider> = 
+  protected abstract getMainBotControlService(): DyNTS_Bot_Main_ControlService<T_MessagingPlatformChannel, T_MessagingPlatformMessage, T_MessagingPlatformUser, T_MessagingPlatformProvider>;
+  protected readonly mainBot_CS: DyNTS_Bot_Main_ControlService<T_MessagingPlatformChannel, T_MessagingPlatformMessage, T_MessagingPlatformUser, T_MessagingPlatformProvider> = 
     this.getMainBotControlService();
 
-  get provider(): T_PlatformProvider {
+  get provider(): T_MessagingPlatformProvider {
     return this.mainBot_CS?.provider;
   }
 
@@ -50,9 +51,9 @@ export abstract class DyNTS_Bot_Commands_ControlService<
     }
   }
 
-  async handleCommand(message: T_PlatformMessage, issuer: string): Promise<void> {
+  async handleCommand(message: T_MessagingPlatformMessage, wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, issuer: string): Promise<void> {
     try {
-      const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Provider_Config;
+      const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_MessagingProvider_Config;
       let haveCommandOperator = false;
       let msg = message.content.replace(
         `<@${this.mainBot_CS.botClientId}>`, ''
@@ -110,7 +111,8 @@ export abstract class DyNTS_Bot_Commands_ControlService<
 
       await commandExists.commandHandler(message);
     } catch (error) {
-      this.provider.replyToMessage(
+      const provider = wrapper?.provider || this.provider;
+      provider.replyToMessage(
         message.id,
         message.channelId,
         `Error occurred while handling the command:\n` +

package/src/_modules/bot/_services/bot-io.control-service.ts

@@ -7,21 +7,22 @@ import { DyNTS_global_settings } from '../../../_collections/global-settings.con
 import { DyNTS_Bot_Message } from '../_models/bot-message.interface'
 import { DyNTS_Bot_Channel } from '../_models/bot-channel.interface'
 import { DyNTS_Bot_User } from '../_models/bot-user.interface'
-import { DyNTS_Bot_Provider } from '../_models/bot-provider.interface'
+import { DyNTS_Bot_MessagingProvider } from '../_models/bot-messaging-provider.interface'
 import { DyNTS_Bot_Global_Settings } from '../_models/bot-global-settings.interface'
+import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface'
 import { DyNTS_Msg_Integration_ControlService } from '../../messaging/_services/msg-integration.control-service'
 
 export abstract class DyNTS_Bot_IO_ControlService<
-  T_PlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
-  T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
-  T_PlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
-  T_PlatformProvider extends DyNTS_Bot_Provider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser> = DyNTS_Bot_Provider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser>
+  T_MessagingPlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
+  T_MessagingPlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
+  T_MessagingPlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
+  T_MessagingPlatformProvider extends DyNTS_Bot_MessagingProvider<T_MessagingPlatformChannel, T_MessagingPlatformMessage, T_MessagingPlatformUser> = DyNTS_Bot_MessagingProvider<T_MessagingPlatformChannel, T_MessagingPlatformMessage, T_MessagingPlatformUser>
 > extends DyNTS_SingletonService {
 
-  protected abstract getMainBotControlService(): DyNTS_Bot_Main_ControlService<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_PlatformProvider>;
-  protected abstract mainBot_CS: DyNTS_Bot_Main_ControlService<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_PlatformProvider>;
+  protected abstract getMainBotControlService(): DyNTS_Bot_Main_ControlService<T_MessagingPlatformChannel, T_MessagingPlatformMessage, T_MessagingPlatformUser, T_MessagingPlatformProvider>;
+  protected abstract mainBot_CS: DyNTS_Bot_Main_ControlService<T_MessagingPlatformChannel, T_MessagingPlatformMessage, T_MessagingPlatformUser, T_MessagingPlatformProvider>;
 
-  get provider(): T_PlatformProvider {
+  get provider(): T_MessagingPlatformProvider {
     return this.mainBot_CS?.provider;
   }
   
@@ -33,8 +34,8 @@ export abstract class DyNTS_Bot_IO_ControlService<
     return this.mainBot_CS.botDisplayName;
   }
 
-  protected abstract getCommandsControlService(): DyNTS_Bot_Commands_ControlService<T_PlatformMessage>;
-  protected commands_CS: DyNTS_Bot_Commands_ControlService<T_PlatformMessage>;
+  protected abstract getCommandsControlService(): DyNTS_Bot_Commands_ControlService<T_MessagingPlatformMessage>;
+  protected commands_CS: DyNTS_Bot_Commands_ControlService<T_MessagingPlatformMessage>;
 
   dontSendErrorReply?: boolean;
 
@@ -64,27 +65,28 @@ export abstract class DyNTS_Bot_IO_ControlService<
     }
   }
 
-  async handleNewMessage(message: T_PlatformMessage, issuer: string): Promise<void> {
+  async handleNewMessage(wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, issuer: string): Promise<void> {
     try {
+      const message = wrapper.message;
       const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
       
       if (botSettings?.debugLevel >= 1) {
-        DyFM_Log.H_log(`incoming message (${message.authorDisplayName}):\n${message.content}`)
+        DyFM_Log.H_log(`incoming message (${message.authorDisplayName}) [${wrapper.providerId}]:\n${message.content}`)
       }
 
-      const isForYou = await this.getMessageIsForBotToHandle(message, issuer);
+      const isForYou = await this.getMessageIsForBotToHandle(message, wrapper, issuer);
 
       if (!isForYou) {
         return;
       }
 
-      const isHandledAsCommand = await this.handleIfCommand(message, issuer);
+      const isHandledAsCommand = await this.handleIfCommand(message, wrapper, issuer);
 
       if (isHandledAsCommand) {
         return;
       }
 
-      await this.handleMessage(message, issuer);
+      await this.handleMessage(message, wrapper, issuer);
       
       // Sync message to messaging system if enabled
       try {
@@ -94,7 +96,7 @@ export abstract class DyNTS_Bot_IO_ControlService<
           // Find or create conversation for this channel
           const conversation = await messagingIntegration.findOrCreateBotConversation(
             message.channelId,
-            this.provider.getProviderName(),
+            wrapper.providerType,
             issuer
           );
           
@@ -115,14 +117,16 @@ export abstract class DyNTS_Bot_IO_ControlService<
       const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
       
       if (!this.dontSendErrorReply && botSettings?.debugLevel >= 1) {
-        await this.provider.replyToMessage(
-          message.id,
-          message.channelId,
-          `[SYSTEM|ERROR|${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-H0] Error occurred while handling the message:\n` +
-          DyFM_Error.getAnyMessage(error)
-        ).catch(error => {
-          DyFM_Error.logSimple('❌❌ Error sending message to report channel:', error);
-        });
+        if (wrapper.provider && wrapper.message) {
+          await wrapper.provider.replyToMessage(
+            wrapper.message.id,
+            wrapper.message.channelId,
+            `[SYSTEM|ERROR|${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-H0] Error occurred while handling the message:\n` +
+            DyFM_Error.getAnyMessage(error)
+          ).catch(err => {
+            DyFM_Error.logSimple('❌❌ Error sending message to report channel:', err);
+          });
+        }
       }
 
       throw new DyFM_Error({
@@ -132,17 +136,19 @@ export abstract class DyNTS_Bot_IO_ControlService<
     }
   }
 
-  abstract handleMessage(message: T_PlatformMessage, issuer: string): Promise<T_PlatformMessage>;
+  abstract handleMessage(message: T_MessagingPlatformMessage, wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, issuer: string): Promise<T_MessagingPlatformMessage>;
 
   async getMessageIsForBotToHandle(
-    message: T_PlatformMessage, 
+    message: T_MessagingPlatformMessage, 
+    wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>,
     issuer: string, 
     dontRemovePing?: boolean
   ): Promise<boolean> {
     try {
       const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
       
-      if (!this.provider || !this.mainBot_CS || !this.botClientId) {
+      const provider = wrapper.provider || this.provider;
+      if (!provider || !this.mainBot_CS || !this.botClientId) {
         DyFM_Log.H_error(
           '🚫❌ Bot not initialized yet. END wont respond to message:', message.content,
           new Error('Bot not initialized yet').stack
@@ -184,7 +190,8 @@ export abstract class DyNTS_Bot_IO_ControlService<
         }
 
         if (!isOwnMessage && isPinged) {
-          this.provider.replyToMessage(
+          const provider = wrapper.provider || this.provider;
+          provider.replyToMessage(
             message.id,
             message.channelId,
             `[SYSTEM|REFUSE|CHANNEL] I'm sorry, but I'm not allowed to answer you in this channel!`
@@ -221,7 +228,8 @@ export abstract class DyNTS_Bot_IO_ControlService<
       ) {
         if (isPinged && botSettings?.debugLevel >= 2) {
           DyFM_Log.warn('🚫🤖❌ not for me; this message is from a bot')
-          this.provider.replyToMessage(
+          const provider = wrapper.provider || this.provider;
+          provider.replyToMessage(
             message.id,
             message.channelId,
             '[SYSTEM|REFUSE|BOT] You should not ping me!'
@@ -247,7 +255,8 @@ export abstract class DyNTS_Bot_IO_ControlService<
       if (!isAllowedUser) {
         if (botSettings?.debugLevel >= 2) {
           DyFM_Log.warn('🚫❌ not allowed user. END', message.authorName, message.authorDisplayName)
-          this.provider.replyToMessage(
+          const provider = wrapper.provider || this.provider;
+          provider.replyToMessage(
             message.id,
             message.channelId,
             `[SYSTEM|REFUSE|USER] I'm sorry, but I'm not allowed to answer you!`
@@ -274,12 +283,12 @@ export abstract class DyNTS_Bot_IO_ControlService<
     }
   }
 
-  async handleIfCommand(message: T_PlatformMessage, issuer: string): Promise<boolean> {
+  async handleIfCommand(message: T_MessagingPlatformMessage, wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, issuer: string): Promise<boolean> {
     try {
       const isCommand = await this.isCommand(message, issuer);
 
       if (isCommand) {
-        await this.commands_CS.handleCommand(message, issuer);
+        await this.commands_CS.handleCommand(message, wrapper, issuer);
       }
 
       return Boolean(isCommand);
@@ -291,7 +300,7 @@ export abstract class DyNTS_Bot_IO_ControlService<
     }
   }
 
-  async isCommand(message: T_PlatformMessage, issuer: string): Promise<boolean> {
+  async isCommand(message: T_MessagingPlatformMessage, issuer: string): Promise<boolean> {
     try {
       const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
       let haveCommandOperator = false;

package/src/_modules/bot/_services/bot-main.control-service.ts

@@ -1,14 +1,16 @@
 import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
 import { DyFM_Async, DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
 import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_Bot_Provider } from '../_models/bot-provider.interface';
+import { DyNTS_Bot_MessagingProvider, DyNTS_Bot_MessagingProvider_Config } from '../_models/bot-messaging-provider.interface';
 import { DyNTS_Bot_Message } from '../_models/bot-message.interface';
 import { DyNTS_Bot_Channel } from '../_models/bot-channel.interface';
 import { DyNTS_Bot_User } from '../_models/bot-user.interface';
-import { DyNTS_Bot_Global_Settings } from '../_models/bot-global-settings.interface';
+import { DyNTS_Bot_Global_Settings, DyNTS_Bot_Settings } from '../_models/bot-global-settings.interface';
 import { DyNTS_GlobalService } from '../../../_services/core/global.service';
 import { DyNTS_Bot_IO_ControlService } from './bot-io.control-service';
 import { DyNTS_Bot_Routines_ControlService } from './bot-routines.control-service';
+import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface';
+import { DyNTS_Bot_MessagingProvider_Factory } from './bot-messaging-provider-factory.service';
 
 /**
  * This is the main control service for the Bot.
@@ -22,26 +24,35 @@ import { DyNTS_Bot_Routines_ControlService } from './bot-routines.control-servic
  */
 
 export abstract class DyNTS_Bot_Main_ControlService<
-  T_PlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
-  T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
-  T_PlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
-  T_PlatformProvider extends DyNTS_Bot_Provider<
-    T_PlatformChannel, 
-    T_PlatformMessage, 
-    T_PlatformUser
-  > = DyNTS_Bot_Provider<
-    T_PlatformChannel, 
-    T_PlatformMessage, 
-    T_PlatformUser
+  T_MessagingPlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
+  T_MessagingPlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
+  T_MessagingPlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
+  T_MessagingPlatformProvider extends DyNTS_Bot_MessagingProvider<
+    T_MessagingPlatformChannel, 
+    T_MessagingPlatformMessage, 
+    T_MessagingPlatformUser
+  > = DyNTS_Bot_MessagingProvider<
+    T_MessagingPlatformChannel, 
+    T_MessagingPlatformMessage, 
+    T_MessagingPlatformUser
   >
 > extends DyNTS_SingletonService {
 
-  protected _provider: T_PlatformProvider;
+  protected _provider: T_MessagingPlatformProvider;
+  protected _providers: Map<string, T_MessagingPlatformProvider> = new Map();
 
-  get provider(): T_PlatformProvider {
+  get provider(): T_MessagingPlatformProvider {
     return this._provider;
   }
 
+  get providers(): Map<string, T_MessagingPlatformProvider> {
+    return this._providers;
+  }
+
+  getProviderById(providerId: string): T_MessagingPlatformProvider | undefined {
+    return this._providers.get(providerId);
+  }
+
   get botClientId(): string {
     return this.provider?.getBotId() ?? DyNTS_global_settings?.bot_settings?.discord?.clientId;
   }
@@ -51,35 +62,35 @@ export abstract class DyNTS_Bot_Main_ControlService<
   }
 
   protected abstract getBotIOControlService(): DyNTS_Bot_IO_ControlService<
-    T_PlatformChannel, 
-    T_PlatformMessage, 
-    T_PlatformUser, 
-    T_PlatformProvider
+    T_MessagingPlatformChannel, 
+    T_MessagingPlatformMessage, 
+    T_MessagingPlatformUser, 
+    T_MessagingPlatformProvider
   >;
   protected botIO_CS: DyNTS_Bot_IO_ControlService<
-    T_PlatformChannel, 
-    T_PlatformMessage, 
-    T_PlatformUser, 
-    T_PlatformProvider
+    T_MessagingPlatformChannel, 
+    T_MessagingPlatformMessage, 
+    T_MessagingPlatformUser, 
+    T_MessagingPlatformProvider
   >;
   
   protected abstract getRoutinesControlService(): DyNTS_Bot_Routines_ControlService<
-    T_PlatformChannel, 
-    T_PlatformMessage, 
-    T_PlatformUser, 
-    T_PlatformProvider
+    T_MessagingPlatformChannel, 
+    T_MessagingPlatformMessage, 
+    T_MessagingPlatformUser, 
+    T_MessagingPlatformProvider
   >;
   protected routines_CS: DyNTS_Bot_Routines_ControlService<
-    T_PlatformChannel, 
-    T_PlatformMessage, 
-    T_PlatformUser, 
-    T_PlatformProvider
+    T_MessagingPlatformChannel, 
+    T_MessagingPlatformMessage, 
+    T_MessagingPlatformUser, 
+    T_MessagingPlatformProvider
   >;
 
-  protected abstract getProvider(): T_PlatformProvider;
+  protected abstract getProvider(): T_MessagingPlatformProvider;
 
   private _channelsByNames: {
-    [key: string]: T_PlatformChannel;
+    [key: string]: T_MessagingPlatformChannel;
   } = {};
 
   private _rolesByNames: {
@@ -112,11 +123,39 @@ export abstract class DyNTS_Bot_Main_ControlService<
     }
   }
 
+  /**
+   * Check if the bot is configured for multiple providers
+   */
+  protected isMultiProviderMode(): boolean {
+    const settings = DyNTS_global_settings.bot_settings as any;
+    return Array.isArray(settings?.providers) && settings.providers.length > 0;
+  }
+
+  /**
+   * Get all provider configurations (supports both single and multi-provider mode)
+   */
+  protected getProviderConfigs(): DyNTS_Bot_MessagingProvider_Config[] {
+    const settings = DyNTS_global_settings.bot_settings as any;
+    
+    if (this.isMultiProviderMode()) {
+      return settings.providers;
+    } else {
+      // Single provider mode - wrap existing config
+      const config = settings as DyNTS_Bot_MessagingProvider_Config;
+      if (!config.providerId) {
+        config.providerId = config.messageProvider || 'default';
+      }
+      return [config];
+    }
+  }
+
   async setup(issuer: string): Promise<void> {
     try {
       await DyFM_Async.delay(100);
 
-      if (!DyNTS_global_settings.bot_settings?.provider) {
+      const configs = this.getProviderConfigs();
+      
+      if (configs.length === 0) {
         throw new Error(
           `No bot provider configured!` +
           `\nPlease set the provider in DyNTS_global_settings.bot_settings.provider` +
@@ -124,6 +163,13 @@ export abstract class DyNTS_Bot_Main_ControlService<
         );
       }
 
+      // If multi-provider mode, initialize all providers
+      if (this.isMultiProviderMode()) {
+        await this.setupMultipleProviders(configs, issuer);
+        return;
+      }
+
+      // Single provider mode (backward compatible)
       if (!this.provider) {
         throw new Error(
           `No bot provider instance found!` +
@@ -163,9 +209,16 @@ export abstract class DyNTS_Bot_Main_ControlService<
           DyFM_Log.success('Ready event registered');
         }
 
-        this.provider.onMessage((message: T_PlatformMessage, messageIssuer: string) => {
+        this.provider.onMessage((message: T_MessagingPlatformMessage, messageIssuer: string) => {
           try {
-            this.botIO_CS.handleNewMessage(message, messageIssuer)
+            const wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage> = {
+              message: message,
+              providerId: 'default',
+              providerType: this.provider.getProviderName() as any,
+              provider: this.provider
+            };
+            
+            this.botIO_CS.handleNewMessage(wrapper, messageIssuer)
           } catch (error) {
             DyFM_Error.logSimple('Error handling new message:', error);
           }
@@ -228,6 +281,85 @@ export abstract class DyNTS_Bot_Main_ControlService<
     }
   }
 
+  private async setupMultipleProviders(
+    configs: DyNTS_Bot_MessagingProvider_Config[], 
+    issuer: string
+  ): Promise<void> {
+    const providers = DyNTS_Bot_MessagingProvider_Factory.createProviders(configs);
+    this._providers = providers as Map<string, T_MessagingPlatformProvider>;
+
+    const setupPromises = Array.from(providers.entries()).map(([providerId, provider]) => {
+      return new Promise<void>((resolve, reject) => {
+        provider.onError((error) => {
+          if (DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
+            DyFM_Error.logSimple(`Bot provider error [${providerId}]:`, error);
+          }
+          DyNTS_GlobalService.globalErrorHandler(error);
+          reject(error);
+        });
+
+        provider.onReady(async () => {
+          if (DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
+            DyFM_Log.success(`Bot logged in as ${provider.getBotDisplayName()} [${providerId}]`);
+          }
+          resolve();
+        });
+
+        provider.onMessage((message, messageIssuer, msgProviderId) => {
+          try {
+            const wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage> = {
+              message: message as T_MessagingPlatformMessage,
+              providerId: msgProviderId || provider.getProviderId() || providerId,
+              providerType: provider.getProviderName() as any,
+              provider: provider as any
+            };
+            
+            this.botIO_CS.handleNewMessage(wrapper, messageIssuer)
+          } catch (error) {
+            DyFM_Error.logSimple('Error handling new message:', error);
+          }
+        });
+
+        const config = configs.find(c => c.providerId === providerId);
+        if (!config) {
+          reject(new Error(`No config found for provider ${providerId}`));
+          return;
+        }
+
+        provider.initialize(config).then(() => {
+          const token = this.getTokenForProviderConfig(config);
+          return provider.login(token);
+        }).catch((error) => {
+          reject(error);
+        });
+      });
+    });
+
+    await Promise.all(setupPromises);
+
+    // Set default provider (first one) for backward compatibility
+    if (this._provider) {
+      this._provider = providers.values().next().value;
+    }
+
+    await this.start(issuer);
+    
+    DyFM_Log.success('All bot providers setup complete');
+  }
+
+  private getTokenForProviderConfig(config: DyNTS_Bot_MessagingProvider_Config): string {
+    switch (config.messageProvider) {
+      case 'discord':
+        return config.discord?.token;
+      case 'slack':
+        return config.slack?.token;
+      case 'teams':
+        return config.teams?.appPassword;
+      default:
+        throw new Error(`Unsupported provider: ${config.messageProvider}`);
+    }
+  }
+
   async start(issuer: string): Promise<void> {
     try {
       this.botIO_CS = this.getBotIOControlService();
@@ -267,7 +399,7 @@ export abstract class DyNTS_Bot_Main_ControlService<
     return this._rolesByNames[roleName];
   }
 
-  async getChannelByName(channelName: string): Promise<T_PlatformChannel> {
+  async getChannelByName(channelName: string): Promise<T_MessagingPlatformChannel> {
     if (!this._channelsByNames[channelName]) {
       this._channelsByNames[channelName] = await this.provider.getChannelByName(channelName);
     }
@@ -279,7 +411,7 @@ export abstract class DyNTS_Bot_Main_ControlService<
     channelName: string,
     message: string,
     issuer: string,
-  ): Promise<T_PlatformMessage> {
+  ): Promise<T_MessagingPlatformMessage> {
     try {
       const channel = await this.getChannelByName(channelName);
 
@@ -317,7 +449,7 @@ export abstract class DyNTS_Bot_Main_ControlService<
   }
 
   async clearChannel(
-    channel: T_PlatformChannel,
+    channel: T_MessagingPlatformChannel,
     issuer: string,
   ): Promise<void> {
     try {

package/src/_modules/bot/_services/bot-messaging-provider-factory.service.ts

@@ -0,0 +1,56 @@
+import { DyNTS_Bot_MessagingProvider, DyNTS_Bot_MessagingProvider_Config } from '../_models/bot-messaging-provider.interface';
+import { DyNTS_Bot_MessageProvider_Type } from '../_enums/bot-message-provider.enum';
+import { DyNTS_DiB_MessagingProvider } from '../_modules/discord-bot/_services/dib-messaging-provider.service';
+import { DyNTS_SlB_MessagingProvider } from '../_modules/slack-bot/_services/slb-messaging-provider.service';
+import { DyNTS_TeB_MessagingProvider } from '../_modules/teams-bot/_services/teb-messaging-provider.service';
+import { DyNTS_DyB_MessagingProvider } from '../_modules/dynamo-bot/_services/dyb-messaging-provider.service';
+
+export class DyNTS_Bot_MessagingProvider_Factory {
+
+  static createProvider(config: DyNTS_Bot_MessagingProvider_Config): DyNTS_Bot_MessagingProvider {
+    switch (config.messageProvider) {
+      case DyNTS_Bot_MessageProvider_Type.discord:
+        return new DyNTS_DiB_MessagingProvider();
+
+      case DyNTS_Bot_MessageProvider_Type.slack:
+        return new DyNTS_SlB_MessagingProvider();
+
+      case DyNTS_Bot_MessageProvider_Type.teams:
+        return new DyNTS_TeB_MessagingProvider();
+
+      case DyNTS_Bot_MessageProvider_Type.dynamo:
+        return new DyNTS_DyB_MessagingProvider();
+
+      case DyNTS_Bot_MessageProvider_Type.custom:
+        if (!config.messageProviderInstance) {
+          throw new Error('Custom provider instance is required when provider type is "custom"');
+        }
+        return config.messageProviderInstance;
+
+      default:
+        throw new Error(`Unsupported provider type: ${config.messageProvider}`);
+    }
+  }
+
+  static createProviders(configs: DyNTS_Bot_MessagingProvider_Config[]): Map<string, DyNTS_Bot_MessagingProvider> {
+    const providers = new Map<string, DyNTS_Bot_MessagingProvider>();
+    const providerIds = new Set<string>();
+
+    for (const config of configs) {
+      if (!config.providerId) {
+        throw new Error('providerId is required when using multiple providers');
+      }
+
+      if (providerIds.has(config.providerId)) {
+        throw new Error(`Duplicate providerId detected: ${config.providerId}`);
+      }
+
+      providerIds.add(config.providerId);
+
+      const provider = this.createProvider(config);
+      providers.set(config.providerId, provider);
+    }
+
+    return providers;
+  }
+}