@futdevpro/nts-dynamo 1.14.28 → 1.14.31

package/src/_modules/bot/_modules/teams-bot/_services/teb-messaging-provider.control-service.ts

@@ -0,0 +1,186 @@
+import { DyFM_AnyError, DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyNTS_Bot_MessagingProvider_ServiceBase, DyNTS_Bot_MessagingProvider_Config, Teams_MessagingProviderConfig } from '../../../_services/bot-messaging-provider.service-base';
+import { DyNTS_Bot_ChannelWrapper } from '../../../_models/bot-channel-wrapper.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_MessagingProvider_Type } from '../../../_enums/bot-message-provider.enum';
+import { DyNTS_Bot_MessageWrapper } from '../../../_models/bot-message-wrapper.interface';
+import { DyNTS_Bot_UserWrapper } from '../../../_models/bot-user-wrapper.interface';
+
+// Stub types for Teams - will be replaced with actual Teams SDK types when implemented
+type TeamsChannel = any;
+type TeamsMessage = any;
+type TeamsUser = any;
+
+export class DyNTS_TeB_MessagingProvider_ControlService extends DyNTS_Bot_MessagingProvider_ServiceBase<
+  TeamsChannel,
+  TeamsMessage,
+  TeamsUser,
+  Teams_MessagingProviderConfig,
+  any
+> {
+  readonly name = 'teams';
+  readonly type = DyNTS_Bot_MessagingProvider_Type.teams;
+
+  get botId(): string {
+    return 'teams-bot-stub';
+  }
+
+  get botDisplayName(): string {
+    return 'Teams Bot (Stub)';
+  }
+  
+  override readonly config: Teams_MessagingProviderConfig;
+
+  /* override protected readonly channelCache: Map<string, TeamsChannel> = new Map();
+  override protected readonly roleCache: Map<string, any> = new Map(); */
+
+  constructor(setConfig: Teams_MessagingProviderConfig) {
+    super();
+    this.config = setConfig;
+  }
+
+  async setup(issuer: string): Promise<void> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async start(issuer: string): Promise<void> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  // Channel operations
+  async getChannelByName(name: string): Promise<DyNTS_Bot_ChannelWrapper<TeamsChannel>> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async getChannelById(id: string): Promise<DyNTS_Bot_ChannelWrapper<TeamsChannel>> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async sendMessageToChannelByName(channelName: string, message: string, issuer: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async getMessagesFromChannelByChannelName(channelName: string, limit?: number): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async getLastMessageInChannel(channelName: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async clearChannel(channelWrapper: DyNTS_Bot_ChannelWrapper<TeamsChannel>): Promise<void> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  // Message operations
+  async sendMessage(channelWrapper: DyNTS_Bot_ChannelWrapper<TeamsChannel>, content: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async replyToMessage(messageWrapper: DyNTS_Bot_MessageWrapper<TeamsMessage>, content: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async sendTyping(channelWrapper: DyNTS_Bot_ChannelWrapper<TeamsChannel>): Promise<void> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async fetchMessagesById(id: string, limit: number): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async fetchMessages(channelWrapper: DyNTS_Bot_ChannelWrapper<TeamsChannel>, limit: number): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async fetchMessagesForMessage(messageWrapper: DyNTS_Bot_MessageWrapper<TeamsMessage>, limit: number): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async fetchAllMessagesWithPaging(channelWrapper: DyNTS_Bot_ChannelWrapper<TeamsChannel>, maxFetch?: number): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async deleteMessage(messageWrapper: DyNTS_Bot_MessageWrapper<TeamsMessage>): Promise<void> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  // User operations
+  async getUserByName(username: string): Promise<DyNTS_Bot_UserWrapper<TeamsUser>> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  getUserMention(userId: string): string {
+    return `<@${userId}>`;
+  }
+
+  async readMembersInChannel(channelName: string): Promise<DyNTS_Bot_UserWrapper<TeamsUser>[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async readMemberNamesInChannel(channelName: string): Promise<string[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  // Advanced message queries
+  async getLastMessageSentBy(channelName: string, username: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async getLastMentionOf(channelName: string, username: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<DyNTS_Bot_LastMessageDate[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async readLastMessageWithMemberNamePingInIt(channelName: string, users: DyNTS_Bot_UserWrapper<TeamsUser>[]): Promise<DyNTS_Bot_LastMentionDate[]> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  // Platform-specific features
+  getRoleByName?(roleName: string): any {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  getRolePingByName?(roleName: string): Promise<string> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  getRolePingsByName?(roleNames: string[]): Promise<string> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  // Event binding
+  create_onMessageEventListener(
+    handler: (message: DyNTS_Bot_MessageWrapper<TeamsMessage>, issuer: string) => void
+  ): void {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  create_onErrorEventListener(handler: (error: DyFM_AnyError) => void): void {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async sendReport(message: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  async sendReportIn(message: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  wrapMessage(message: TeamsMessage): DyNTS_Bot_MessageWrapper<TeamsMessage> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  wrapChannel(channel: TeamsChannel): DyNTS_Bot_ChannelWrapper<TeamsChannel> {
+    throw new Error('Teams provider not yet implemented');
+  }
+
+  wrapUser(user: TeamsUser): DyNTS_Bot_UserWrapper<TeamsUser> {
+    throw new Error('Teams provider not yet implemented');
+  }
+}

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

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

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

@@ -3,37 +3,31 @@ import { DyFM_Error } from '@futdevpro/fsm-dynamo';
 import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
 import { DyNTS_Bot_Main_ControlService } from './bot-main.control-service';
 import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-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_MessagingProvider, DyNTS_Bot_MessagingProvider_Config } from '../_models/bot-messaging-provider.interface';
+import { DyNTS_Bot_MessagingProvider_ServiceBase } from './bot-messaging-provider.service-base';
 import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface';
+import { DyNTS_Bot_Global_Settings } from '../_models/bot-global-settings.interface';
+import { DyNTS_Bot_MessagingProvider_Type } from '../_enums/bot-message-provider.enum';
 
-export abstract class DyNTS_Bot_Commands_ControlService<
-  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> {
+export abstract class DyNTS_Bot_Commands_ControlService extends DyNTS_SingletonService {
+
+  // the getInstance() should be implemented in the concrete child class
+  /* static getInstance(): DyNTS_Bot_Commands_ControlService {
     return DyNTS_Bot_Commands_ControlService.getSingletonInstance();
-  }
+  } */
 
-  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();
+  protected mainBot_CS: DyNTS_Bot_Main_ControlService;
+  protected abstract getMainBotControlService(): DyNTS_Bot_Main_ControlService;
 
-  get provider(): T_MessagingPlatformProvider {
-    return this.mainBot_CS?.provider;
+  
+  get defaultProvider(): DyNTS_Bot_MessagingProvider_ServiceBase<any, any, any> {
+    return this.mainBot_CS.defaultProvider;
   }
 
-  protected constructor() {
+  /* get provider(): DyNTS_Bot_MessagingProvider<any, any, any> {
+    return this.mainBot_CS?.provider;
+  } */
+
+  /* protected constructor() {
     super();
 
     if (!this.provider) {
@@ -49,14 +43,52 @@ export abstract class DyNTS_Bot_Commands_ControlService<
         errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-C00`,
       })
     }
+  } */
+ 
+  async setup(issuer: string): Promise<void> {
+    try {
+      this.mainBot_CS = this.getMainBotControlService();
+
+      if (!this.mainBot_CS) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings('setup', new Error('Main Bot Control Service not found'), issuer),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-S01`,
+        })
+      }
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('setup', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-S000`,
+      })
+    }
   }
 
-  async handleCommand(message: T_MessagingPlatformMessage, wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, issuer: string): Promise<void> {
+  async start(issuer: string): Promise<void> {
     try {
-      const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_MessagingProvider_Config;
-      let haveCommandOperator = false;
-      let msg = message.content.replace(
-        `<@${this.mainBot_CS.botClientId}>`, ''
+      if (!this.defaultProvider) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings('start', new Error('Bot provider not yet started'), issuer),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-ST00`,
+        })
+      }
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('start', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-ST00`,
+      })
+    }
+  }
+
+  async handleCommand<T_MessagingPlatformMessage extends any = any>(
+    message: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, 
+    issuer: string
+  ): Promise<void> {
+    try {
+      const botSettings: DyNTS_Bot_Global_Settings = DyNTS_global_settings.bot_settings;
+      let haveCommandOperator: boolean = false;
+      let msg: string = message.content.replace(
+        message.provider.getUserMention(message.provider.botId), ''
+        //`<@${this.mainBot_CS.botClientId}>`, ''
       ).trim();
 
       if (!botSettings?.commandSettings?.commandOperator) {
@@ -111,13 +143,11 @@ export abstract class DyNTS_Bot_Commands_ControlService<
 
       await commandExists.commandHandler(message);
     } catch (error) {
-      const provider = wrapper?.provider || this.provider;
-      provider.replyToMessage(
-        message.id,
-        message.channelId,
+      message.provider.replyToMessage(
+        message,
         `Error occurred while handling the command:\n` +
         DyFM_Error.getAnyMessage(error)
-      )
+      );
 
       throw new DyFM_Error({
         ...this.getDefaultErrorSettings('handleCommand', error, issuer),

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

@@ -4,25 +4,23 @@ import { DyNTS_Bot_Commands_ControlService } from './bot-commands.control-servic
 import { DyNTS_SingletonService } from '../../../_services/base/singleton.service'
 import { DyNTS_Bot_Main_ControlService } from './bot-main.control-service'
 import { DyNTS_global_settings } from '../../../_collections/global-settings.const'
-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_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'
+import { DyNTS_Bot_MessagingProvider_ServiceBase } from './bot-messaging-provider.service-base'
 
-export abstract class DyNTS_Bot_IO_ControlService<
-  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 {
+export abstract class DyNTS_Bot_IO_ControlService extends DyNTS_SingletonService {
 
-  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>;
+  protected abstract getMainBotControlService(): DyNTS_Bot_Main_ControlService;
+  protected mainBot_CS: DyNTS_Bot_Main_ControlService;
 
-  get provider(): T_MessagingPlatformProvider {
+  protected abstract getCommandsControlService(): DyNTS_Bot_Commands_ControlService;
+  protected commands_CS: DyNTS_Bot_Commands_ControlService;
+
+  get defaultProvider(): DyNTS_Bot_MessagingProvider_ServiceBase<any, any, any> {
+    return this.mainBot_CS.defaultProvider;
+  }
+
+  /* get provider(): DyNTS_Bot_MessagingProvider<any, any, any> {
     return this.mainBot_CS?.provider;
   }
   
@@ -32,26 +30,46 @@ export abstract class DyNTS_Bot_IO_ControlService<
   
   get botDisplayName(): string {
     return this.mainBot_CS.botDisplayName;
-  }
-
-  protected abstract getCommandsControlService(): DyNTS_Bot_Commands_ControlService<T_MessagingPlatformMessage>;
-  protected commands_CS: DyNTS_Bot_Commands_ControlService<T_MessagingPlatformMessage>;
+  } */
 
   dontSendErrorReply?: boolean;
 
-  async start(issuer: string): Promise<void> {
+  async setup(issuer: string): Promise<void> {
     try {
       this.mainBot_CS = this.getMainBotControlService();
       this.commands_CS = this.getCommandsControlService();
 
-      if (!this.provider) {
+      if (!this.mainBot_CS) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings('setup', new Error('Main Bot Control Service not found'), issuer),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-S01`,
+        })
+      }
+
+      if (!this.commands_CS) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings('setup', new Error('Commands Control Service not found'), issuer),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-S02`,
+        })
+      }
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('setup', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-S000`,
+      })
+    }
+  }
+
+  async start(issuer: string): Promise<void> {
+    try {
+      if (!this.defaultProvider) {
         throw new DyFM_Error({
           ...this.getDefaultErrorSettings(
             'constructor', 
             new Error(
               'Bot provider not yet initialized, ' +
               'should only be called after DyNTS_Bot_Main_ControlService.start'
-            ), 
+            ),
             'system-init'
           ),
           errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-IO-C000`,
@@ -65,64 +83,51 @@ export abstract class DyNTS_Bot_IO_ControlService<
     }
   }
 
-  async handleNewMessage(wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, issuer: string): Promise<void> {
+  abstract handleMessage<T_MessagingPlatformMessage extends any = any>(
+    message: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>,
+    issuer: string
+  ): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>;
+
+  /**
+   * This is the internal handler for new messages, which will call the handleMessage() method.
+   */
+  async _handleNewMessage<T_MessagingPlatformMessage extends any = any>(
+    message: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>,
+    issuer: string
+  ): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>> {
     try {
-      const message = wrapper.message;
-      const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
+      /* const message = message.message; */
+      const botSettings: DyNTS_Bot_Global_Settings = DyNTS_global_settings.bot_settings;
       
       if (botSettings?.debugLevel >= 1) {
-        DyFM_Log.H_log(`incoming message (${message.authorDisplayName}) [${wrapper.providerId}]:\n${message.content}`)
+        DyFM_Log.H_log(`incoming message (${message.authorDisplayName}) [${message.provider.type}]:\n${message.content}`)
       }
 
-      const isForYou = await this.getMessageIsForBotToHandle(message, wrapper, issuer);
+      const isForYou = await this.getMessageIsForBotToHandle(message, issuer);
 
       if (!isForYou) {
         return;
       }
 
-      const isHandledAsCommand = await this.handleIfCommand(message, wrapper, issuer);
+      const isHandledAsCommand = await this.handleIfCommand(message, issuer);
 
       if (isHandledAsCommand) {
         return;
       }
 
-      await this.handleMessage(message, wrapper, issuer);
-      
-      // Sync message to messaging system if enabled
-      try {
-        if (DyNTS_global_settings.messaging_settings?.integration?.syncBotMessages) {
-          const messagingIntegration = DyNTS_Msg_Integration_ControlService.getInstance();
-          
-          // Find or create conversation for this channel
-          const conversation = await messagingIntegration.findOrCreateBotConversation(
-            message.channelId,
-            wrapper.providerType,
-            issuer
-          );
-          
-          // Sync the message
-          await messagingIntegration.syncBotMessage(
-            message,
-            conversation._id!,
-            issuer
-          );
-        }
-      } catch (syncError) {
-        // Log sync error but don't break bot functionality
-        DyFM_Log.error('Failed to sync bot message to messaging system', syncError);
-      }
+      return await this.handleMessage(message, issuer);
     } catch (error) {
       DyFM_Error.logSimple('❌❌ Error handleNewMessage:', error);
 
       const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
       
       if (!this.dontSendErrorReply && botSettings?.debugLevel >= 1) {
-        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)
+        if (message.provider) {
+          await message.provider.replyToMessage(
+            message,
+            `[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);
           });
@@ -136,42 +141,28 @@ export abstract class DyNTS_Bot_IO_ControlService<
     }
   }
 
-  abstract handleMessage(message: T_MessagingPlatformMessage, wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, issuer: string): Promise<T_MessagingPlatformMessage>;
-
-  async getMessageIsForBotToHandle(
-    message: T_MessagingPlatformMessage, 
-    wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>,
-    issuer: string, 
-    dontRemovePing?: boolean
+  async getMessageIsForBotToHandle<T_MessagingPlatformMessage extends any = any>(
+    message: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>,
+    issuer: string,
   ): Promise<boolean> {
     try {
       const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
       
-      const provider = wrapper.provider || this.provider;
-      if (!provider || !this.mainBot_CS || !this.botClientId) {
+      if (!message.provider || !this.mainBot_CS || !message.provider.botId) {
         DyFM_Log.H_error(
           '🚫❌ Bot not initialized yet. END wont respond to message:', message.content,
           new Error('Bot not initialized yet').stack
         )
 
-        await this.start(issuer);
-
-        if (!this.provider || !this.mainBot_CS || !this.botClientId) {
-          DyFM_Log.H_error(
-            '🚫❌❌ can not start bot. END wont respond to message:', message.content,
-            new Error('can not start bot').stack
-          )
-        }
-
         return false;
       }
 
       const isReplyForYou = message.replyToMessageId && message.replyToMessageId; // Simplified check
-      const isPinged = message.content.includes(this.botClientId) || 
-        message.content.includes(`@${this.botDisplayName}`) ||
+      const isPinged = message.content.includes(message.provider.botId) || 
+        message.content.includes(`@${message.provider.botDisplayName}`) ||
         isReplyForYou;
-      const isOwnMessage = message.authorId === this.botClientId || 
-        message.authorDisplayName === this.botDisplayName;
+      const isOwnMessage = message.authorId === message.provider.botId || 
+        message.authorDisplayName === message.provider.botDisplayName;
       const haveSkipFlags = botSettings?.messageSettings?.skipFlags?.some(
         flag => message.content.includes(flag)
       ) || false;
@@ -190,10 +181,8 @@ export abstract class DyNTS_Bot_IO_ControlService<
         }
 
         if (!isOwnMessage && isPinged) {
-          const provider = wrapper.provider || this.provider;
-          provider.replyToMessage(
-            message.id,
-            message.channelId,
+          message.provider.replyToMessage(
+            message,
             `[SYSTEM|REFUSE|CHANNEL] I'm sorry, but I'm not allowed to answer you in this channel!`
           )
         }
@@ -228,10 +217,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')
-          const provider = wrapper.provider || this.provider;
-          provider.replyToMessage(
-            message.id,
-            message.channelId,
+          message.provider.replyToMessage(
+            message,
             '[SYSTEM|REFUSE|BOT] You should not ping me!'
           )
         }
@@ -255,10 +242,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)
-          const provider = wrapper.provider || this.provider;
-          provider.replyToMessage(
-            message.id,
-            message.channelId,
+          message.provider.replyToMessage(
+            message,
             `[SYSTEM|REFUSE|USER] I'm sorry, but I'm not allowed to answer you!`
           )
         }
@@ -283,12 +268,15 @@ export abstract class DyNTS_Bot_IO_ControlService<
     }
   }
 
-  async handleIfCommand(message: T_MessagingPlatformMessage, wrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, issuer: string): Promise<boolean> {
+  async handleIfCommand<T_MessagingPlatformMessage extends any = any>(
+    message: 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, wrapper, issuer);
+        await this.commands_CS.handleCommand(message, issuer);
       }
 
       return Boolean(isCommand);
@@ -300,7 +288,10 @@ export abstract class DyNTS_Bot_IO_ControlService<
     }
   }
 
-  async isCommand(message: T_MessagingPlatformMessage, issuer: string): Promise<boolean> {
+  async isCommand<T_MessagingPlatformMessage extends any = any>(
+    message: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>,
+    issuer: string
+  ): Promise<boolean> {
     try {
       const botSettings = DyNTS_global_settings.bot_settings as DyNTS_Bot_Global_Settings;
       let haveCommandOperator = false;