@futdevpro/nts-dynamo 1.14.26 → 1.14.28

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

@@ -7,29 +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_MessageProvider, DyNTS_Bot_MessageProvider_Config } from '../_models/bot-message-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_MessageProvider<
-    T_PlatformChannel, 
-    T_PlatformMessage, 
-    T_PlatformUser
-  > = DyNTS_Bot_MessageProvider<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;
   }
 
@@ -51,9 +51,9 @@ export abstract class DyNTS_Bot_Commands_ControlService<
     }
   }
 
-  async handleCommand(message: T_PlatformMessage, wrapper: DyNTS_Bot_MessageWrapper<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_MessageProvider_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}>`, ''

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

@@ -7,22 +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_MessageProvider } from '../_models/bot-message-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_MessageProvider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser> = DyNTS_Bot_MessageProvider<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;
   }
   
@@ -34,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;
 
@@ -65,22 +65,9 @@ export abstract class DyNTS_Bot_IO_ControlService<
     }
   }
 
-  async handleNewMessage(wrapperOrMessage: DyNTS_Bot_MessageWrapper<T_PlatformMessage> | T_PlatformMessage, issuer: string): Promise<void> {
-    // Declare variables outside try-catch for error handling
-    let wrapper: DyNTS_Bot_MessageWrapper<T_PlatformMessage>;
-    let message: T_PlatformMessage;
-    
+  async handleNewMessage(wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, issuer: string): Promise<void> {
     try {
-      // Support both wrapped messages (multi-provider) and unwrapped (backward compatibility)
-      const isWrapper = 'message' in wrapperOrMessage && 'providerId' in wrapperOrMessage;
-      wrapper = isWrapper ? wrapperOrMessage as DyNTS_Bot_MessageWrapper<T_PlatformMessage> : {
-        message: wrapperOrMessage as T_PlatformMessage,
-        providerId: 'default',
-        providerType: this.provider.getProviderName() as any,
-        provider: this.provider
-      };
-      
-      message = wrapper.message;
+      const message = wrapper.message;
       const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
       
       if (botSettings?.debugLevel >= 1) {
@@ -130,14 +117,10 @@ 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) {
-        // Use wrapper if available, fallback to default provider
-        const errorProvider = wrapper?.provider || this.provider;
-        const errorMessage = wrapper?.message || message;
-        
-        if (errorProvider && errorMessage) {
-          await errorProvider.replyToMessage(
-            errorMessage.id,
-            errorMessage.channelId,
+        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 => {
@@ -153,11 +136,11 @@ export abstract class DyNTS_Bot_IO_ControlService<
     }
   }
 
-  abstract handleMessage(message: T_PlatformMessage, wrapper: DyNTS_Bot_MessageWrapper<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, 
-    wrapper: DyNTS_Bot_MessageWrapper<T_PlatformMessage>,
+    message: T_MessagingPlatformMessage, 
+    wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>,
     issuer: string, 
     dontRemovePing?: boolean
   ): Promise<boolean> {
@@ -300,7 +283,7 @@ export abstract class DyNTS_Bot_IO_ControlService<
     }
   }
 
-  async handleIfCommand(message: T_PlatformMessage, wrapper: DyNTS_Bot_MessageWrapper<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);
 
@@ -317,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,7 +1,7 @@
 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_MessageProvider, DyNTS_Bot_MessageProvider_Config } from '../_models/bot-message-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';
@@ -10,7 +10,7 @@ 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_Provider_Factory } from './bot-provider-factory.service';
+import { DyNTS_Bot_MessagingProvider_Factory } from './bot-messaging-provider-factory.service';
 
 /**
  * This is the main control service for the Bot.
@@ -24,32 +24,32 @@ import { DyNTS_Bot_Provider_Factory } from './bot-provider-factory.service';
  */
 
 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_MessageProvider<
-    T_PlatformChannel, 
-    T_PlatformMessage, 
-    T_PlatformUser
-  > = DyNTS_Bot_MessageProvider<
-    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 _providers: Map<string, T_PlatformProvider> = new Map();
+  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_PlatformProvider> {
+  get providers(): Map<string, T_MessagingPlatformProvider> {
     return this._providers;
   }
 
-  getProviderById(providerId: string): T_PlatformProvider | undefined {
+  getProviderById(providerId: string): T_MessagingPlatformProvider | undefined {
     return this._providers.get(providerId);
   }
 
@@ -62,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: {
@@ -134,14 +134,14 @@ export abstract class DyNTS_Bot_Main_ControlService<
   /**
    * Get all provider configurations (supports both single and multi-provider mode)
    */
-  protected getProviderConfigs(): DyNTS_Bot_MessageProvider_Config[] {
+  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_MessageProvider_Config;
+      const config = settings as DyNTS_Bot_MessagingProvider_Config;
       if (!config.providerId) {
         config.providerId = config.messageProvider || 'default';
       }
@@ -209,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);
           }
@@ -275,11 +282,11 @@ export abstract class DyNTS_Bot_Main_ControlService<
   }
 
   private async setupMultipleProviders(
-    configs: DyNTS_Bot_MessageProvider_Config[], 
+    configs: DyNTS_Bot_MessagingProvider_Config[], 
     issuer: string
   ): Promise<void> {
-    const providers = DyNTS_Bot_Provider_Factory.createProviders(configs);
-    this._providers = providers as Map<string, T_PlatformProvider>;
+    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) => {
@@ -300,8 +307,8 @@ export abstract class DyNTS_Bot_Main_ControlService<
 
         provider.onMessage((message, messageIssuer, msgProviderId) => {
           try {
-            const wrapper: DyNTS_Bot_MessageWrapper<T_PlatformMessage> = {
-              message: message as T_PlatformMessage,
+            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
@@ -340,7 +347,7 @@ export abstract class DyNTS_Bot_Main_ControlService<
     DyFM_Log.success('All bot providers setup complete');
   }
 
-  private getTokenForProviderConfig(config: DyNTS_Bot_MessageProvider_Config): string {
+  private getTokenForProviderConfig(config: DyNTS_Bot_MessagingProvider_Config): string {
     switch (config.messageProvider) {
       case 'discord':
         return config.discord?.token;
@@ -392,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);
     }
@@ -404,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);
 
@@ -442,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_MessagingProvider_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_MessagingProvider_Type.discord:
+        return new DyNTS_DiB_MessagingProvider();
+
+      case DyNTS_Bot_MessagingProvider_Type.slack:
+        return new DyNTS_SlB_MessagingProvider();
+
+      case DyNTS_Bot_MessagingProvider_Type.teams:
+        return new DyNTS_TeB_MessagingProvider();
+
+      case DyNTS_Bot_MessagingProvider_Type.dynamo:
+        return new DyNTS_DyB_MessagingProvider();
+
+      case DyNTS_Bot_MessagingProvider_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;
+  }
+}

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

@@ -8,17 +8,17 @@ import { DyNTS_global_settings } from '../../../_collections/global-settings.con
 import { DyNTS_Bot_Channel } from '../_models/bot-channel.interface';
 import { DyNTS_Bot_Message } from '../_models/bot-message.interface';
 import { DyNTS_Bot_User } from '../_models/bot-user.interface';
-import { DyNTS_Bot_MessageProvider } from '../_models/bot-message-provider.interface';
+import { DyNTS_Bot_MessagingProvider } from '../_models/bot-messaging-provider.interface';
 
 export abstract class DyNTS_Bot_Routines_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_MessageProvider<
+  T_PlatformProvider extends DyNTS_Bot_MessagingProvider<
     T_PlatformChannel, 
     T_PlatformMessage, 
     T_PlatformUser
-  > = DyNTS_Bot_MessageProvider<
+  > = DyNTS_Bot_MessagingProvider<
     T_PlatformChannel, 
     T_PlatformMessage, 
     T_PlatformUser

package/src/_modules/bot/index.ts

@@ -13,7 +13,7 @@ export * from './_models/bot-message.interface';
 export * from './_models/bot-message-wrapper.interface';
 export * from './_models/bot-channel.interface';
 export * from './_models/bot-user.interface';
-export * from './_models/bot-message-provider.interface';
+export * from './_models/bot-messaging-provider.interface';
 export * from './_models/bot-command.interface';
 export * from './_models/bot-global-settings.interface';
 export * from './_models/bot-last-message-date.interface';
@@ -29,7 +29,7 @@ export * from './_services/bot-main.control-service';
 export * from './_services/bot-io.control-service';
 export * from './_services/bot-commands.control-service';
 export * from './_services/bot-routines.control-service';
-export * from './_services/bot-provider-factory.service';
+export * from './_services/bot-messaging-provider-factory.service';
 
 // PROVIDERS
 export * from './_modules/discord-bot';

package/src/_modules/discord-assistant/_collections/dias.util.ts

@@ -2,9 +2,8 @@ import { Message, TextChannel } from 'discord.js';
 
 import { DyFM_Error } from '@futdevpro/fsm-dynamo';
 
-import { DyNTS_OAI_GPT_Message } from '../../ai/_modules/open-ai/_models/interfaces/oai-gpt-message.interface';
+import { DyFM_AI_Message, DyFM_AI_MessageRole } from '@futdevpro/fsm-dynamo/ai';
 import { DyNTS_DiAs_global_settings } from './dias-global-settings.const';
-import { DyNTS_OAI_GPT_Message_Role } from '../../ai/_modules/open-ai/_enums/oai-gpt-message-role.enum';
 
 
 export class DyNTS_DiAs_Util {
@@ -16,7 +15,7 @@ export class DyNTS_DiAs_Util {
       botDisplayName: string,
       issuer: string,
     }
-  ): DyNTS_OAI_GPT_Message[] {
+  ): DyFM_AI_Message[] {
 
     return set.messages.map(message => {
       if (
@@ -29,18 +28,18 @@ export class DyNTS_DiAs_Util {
           flag => message.content.includes(flag)
         )) {
           return {
-            role: DyNTS_OAI_GPT_Message_Role.user,
+            role: DyFM_AI_MessageRole.user,
             content: message.content,
           };
         } else {
           return {
-            role: DyNTS_OAI_GPT_Message_Role.assistant,
+            role: DyFM_AI_MessageRole.assistant,
             content: message.content,
           };
         }
       } else {
         return {
-          role: DyNTS_OAI_GPT_Message_Role.user,
+          role: DyFM_AI_MessageRole.user,
           content: message.content,
         };
       }
@@ -55,7 +54,7 @@ export class DyNTS_DiAs_Util {
       issuer: string,
       skipFlags?: string[],
     }
-  ): Promise<DyNTS_OAI_GPT_Message[]> {
+  ): Promise<DyFM_AI_Message[]> {
     const messages: Message[] = await this.gatherMessagesForMessage(set/* message, botClientId, issuer, skipFlags */);
 
     return DyNTS_DiAs_Util.convertDiscordMessagesToOAIConversation({

package/src/_modules/discord-assistant/_services/dias-chunk.data-service.ts

@@ -8,7 +8,7 @@ import { DyFM_DataModel_Params, DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dyna
 // import { DyFM_OAI_Model } from '@futdevpro/fsm-dynamo';
 import { DyNTS_DiAs_Main_ControlService } from './dias-main.control-service';
 import { DyNTS_AI_LLMChat_ServiceBase } from '../../ai/_services/ai-llm-chat.service-base';
-import { DyNTS_OAI_GPT_Message } from '../../ai/_modules/open-ai/_models/interfaces/oai-gpt-message.interface';
+import { DyFM_AI_Message } from '@futdevpro/fsm-dynamo/ai';
 import { DyNTS_OAI_LLMDefaultPredefined_Requests } from '../../ai/_modules/open-ai/_collections/oai-llm-predefined-requests.conts';
 import { DyNTS_DAI_Document_Util } from '../../ai/_modules/document-ai/_collections/dai-document.util';
 import { DyNTS_DAI_DocPage } from '../../ai/_modules/document-ai/_models/data-models/dai-doc-page.data-model';
@@ -54,7 +54,7 @@ export abstract class DyNTS_DiAs_Chunk_DataService<
   /* abstract getPageLink(page: T_Page): string; */
 
   async resolveConversation(
-    conversation: DyNTS_OAI_GPT_Message[],
+    conversation: DyFM_AI_Message[],
     limit: number = 10,
     numberOfCandidates: number = 200,
   ): Promise<string> {
@@ -96,7 +96,7 @@ export abstract class DyNTS_DiAs_Chunk_DataService<
   // add code overview by coding policies 
   //  (Milyen jellegű coding policies lehet releváns az adott kérdésben)
   async vectorSearchAndResolveConversation(
-    conversation: DyNTS_OAI_GPT_Message[],
+    conversation: DyFM_AI_Message[],
     limit: number = 3,
     numberOfCandidates: number = 100,
   ): Promise<string> {
@@ -139,12 +139,12 @@ export abstract class DyNTS_DiAs_Chunk_DataService<
 
   // TODO: EZT KELL HÍVNI PARANCSRA 
   async vectorSearchUsingConversation(
-    conversation: DyNTS_OAI_GPT_Message[],
+    conversation: DyFM_AI_Message[],
     limit: number = 3,
     numberOfCandidates: number = 100,
   ): Promise<T_Chunk[]> {
     try {
-      const lastMessage: DyNTS_OAI_GPT_Message = conversation[conversation.length - 1];
+      const lastMessage: DyFM_AI_Message = conversation[conversation.length - 1];
 
       const searchQuestion: string = await this.llmChat_CS.getAnswerInConversation({
         conversation: conversation,

package/src/_modules/discord-assistant/_services/dias-io.control-service.ts

@@ -8,7 +8,7 @@ import { DyNTS_DiBo_IO_ControlService } from '../../discord-bot/_services/dibo-i
 import { DyNTS_DiAs_Main_ControlService } from './dias-main.control-service'
 import { DyNTS_DiBo_global_settings } from '../../discord-bot/_collections/dibo-global-settings.conts'
 import { DyNTS_OAI_LLMChat_ServiceBase } from '../../ai/_modules/open-ai/_services/oai-llm-chat.service-base'
-import { DyNTS_OAI_GPT_Message } from '../../ai/_modules/open-ai/_models/interfaces/oai-gpt-message.interface'
+import { DyFM_AI_Message } from '@futdevpro/fsm-dynamo/ai';
 import { DyNTS_DiAs_Util } from '../_collections/dias.util'
 
 export abstract class DyNTS_DiAs_IO_ControlService extends DyNTS_DiBo_IO_ControlService {
@@ -31,7 +31,7 @@ export abstract class DyNTS_DiAs_IO_ControlService extends DyNTS_DiBo_IO_Control
   override async handleMessage(message: Message, issuer: string): Promise<Message> {
     try {
       const messages: Message[] = await this.mainDiscordBot_CS.gatherDiscordMessagesForMessage(message);
-      const oaiMessages: DyNTS_OAI_GPT_Message[] = 
+      const oaiMessages: DyFM_AI_Message[] = 
         DyNTS_DiAs_Util.convertDiscordMessagesToOAIConversation({
           messages: messages,
           botClientId: this.mainDiscordBot_CS.botClientId,

package/src/_modules/discord-assistant/_services/dias.service-base.ts

@@ -5,8 +5,7 @@ import { Client, Guild, Message, TextChannel } from 'discord.js';
 import { DyNTS_DiBo_Main_ControlService } from '../../discord-bot/_services/dibo-main.control-service';
 import { DyNTS_DiAs_global_settings } from '../_collections/dias-global-settings.const';
 import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_OAI_GPT_Message } from '../../ai/_modules/open-ai/_models/interfaces/oai-gpt-message.interface';
-import { DyNTS_OAI_GPT_Message_Role } from '../../ai/_modules/open-ai/_enums/oai-gpt-message-role.enum';
+import { DyFM_AI_Message } from '@futdevpro/fsm-dynamo/ai';
 import { DyNTS_DiAs_Util } from '../_collections/dias.util';
 import { DyNTS_DiAs_IO_ControlService } from './dias-io.control-service';
 
@@ -65,7 +64,7 @@ export abstract class DyNTS_DiAs_ServiceBase extends DyNTS_DiBo_Main_ControlServ
   async gatherMessagesAsOAIConversation(
     message: Message,
     issuer: string,
-  ): Promise<DyNTS_OAI_GPT_Message[]> {
+  ): Promise<DyFM_AI_Message[]> {
     const messages: Message[] = await this.gatherDiscordMessagesForMessage(message); 
 
     return DyNTS_DiAs_Util.convertDiscordMessagesToOAIConversation({

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

@@ -242,6 +242,8 @@ export abstract class DyNTS_DiBo_Main_ControlService extends DyNTS_SingletonServ
 
         this.client.on('messageCreate', (message: Message) => {
           try {
+            // Discord-specific implementation doesn't use generic wrapper pattern
+            // It has its own handleNewMessage signature
             this.botIO_CS.handleNewMessage(message, message?.author?.id ?? 'unknown')
           } catch (error) {
             DyFM_Error.logSimple('Error handling new message:', error);