@futdevpro/nts-dynamo 1.15.151 → 1.15.153

package/src/_modules/bot/_modules/dynamo-bot/_services/dyb-messaging-provider.control-service.ts

@@ -1,447 +1,447 @@
-import { DyFM_AnyError, DyFM_Array, DyFM_Error, DyFM_Log, week } from '@futdevpro/fsm-dynamo';
-import { 
-  DyFM_Msg_Provider_Type, DyFM_Msg_Conversation, DyFM_Msg_EventKey, DyFM_Msg_Message, DyFM_Msg_Participant 
-} from '@futdevpro/fsm-dynamo/messaging';
-
-import { 
-  DyNTS_Bot_MessagingProvider_ServiceBase, DyNTS_Bot_MessagingProvider_Config 
-} 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_MessageWrapper } from '../../../_models/bot-message-wrapper.interface';
-import { DyNTS_Bot_UserWrapper } from '../../../_models/bot-user-wrapper.interface';
-import { DyNTS_DyB_Message, DyNTS_DyB_Channel, DyNTS_DyB_User } from '../_models/dyb-platform.types';
-import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
-import { DyNTS_Msg_Main_ControlService } from '../../../../messaging/_services/msg-main.control-service';
-import { DyNTS_Msg_Message_DataService } from '../../../../messaging/_services/msg-message.data-service';
-import { DyNTS_Msg_Conversation_DataService } from '../../../../messaging/_services/msg-conversation.data-service';
-import { DyNTS_Msg_Events_Service } from '../../../../messaging/_services/msg-events.service';
-
-export interface Dynamo_MessagingProviderConfig extends DyNTS_Bot_MessagingProvider_Config {
-  botUserId?: string;
-  botDisplayName?: string;
-}
-
-export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_MessagingProvider_ServiceBase<
-  DyFM_Msg_Conversation,
-  DyFM_Msg_Message,
-  DyFM_Msg_Participant,
-  Dynamo_MessagingProviderConfig,
-  any
-> {
-  readonly name = 'dynamo';
-  readonly type = DyFM_Msg_Provider_Type.dynamo;
-
-  get botId(): string {
-    return this.config.botUserId || 'dynamo-bot';
-  }
-
-  get botDisplayName(): string {
-    return this.config.botDisplayName || 'Dynamo Bot';
-  }
-  
-  readonly config: Dynamo_MessagingProviderConfig;
-
-  /* protected override readonly channelCache: Map<string, DyFM_Msg_Conversation> = new Map();
-  protected override readonly roleCache: Map<string, any> = new Map(); */
-
-  // Services
-  private messaging_CS: DyNTS_Msg_Main_ControlService;
-  private eventsService: DyNTS_Msg_Events_Service;
-
-  constructor(setConfig: Dynamo_MessagingProviderConfig) {
-    super();
-    this.config = setConfig;
-    this.messaging_CS = DyNTS_Msg_Main_ControlService.getInstance();
-    this.eventsService = DyNTS_Msg_Events_Service.getInstance();
-  }
-
-  async setup(issuer: string): Promise<void> {
-    try {
-      DyFM_Log.success('Dynamo bot provider setup completed');
-    } catch (error) {   
-      DyFM_Error.logSimple('Error during Dynamo bot setup:', error);
-
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('setup', error, issuer),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DyB-MessagingProvider-S000`,
-      });
-    }
-  }
-
-  async start(issuer: string): Promise<void> {
-    try {
-      // Setup event listeners for messaging events
-      this.setupEventListeners();
-      DyFM_Log.success('Dynamo bot provider started');
-    } catch (error) {
-      DyFM_Error.logSimple('Error during Dynamo bot start:', error);
-
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('start', error, issuer),
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DyB-MessagingProvider-S001`,
-      });
-    }
-  }
-
-  private setupEventListeners(): void {
-    // Listen to messaging events and convert them to bot events
-    // Note: This would require extending the events service to support custom listeners
-    // For now, we'll implement a basic approach
-    DyFM_Log.info('Dynamo bot event listeners setup (messaging integration)');
-  }
-
-  // Channel operations
-  async getChannelByName(name: string): Promise<DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>> {
-    if (this.channelCache.has(name)) {
-      return await this.wrapChannel(this.channelCache.get(name));
-    }
-
-    const conversationService: DyNTS_Msg_Conversation_DataService = new DyNTS_Msg_Conversation_DataService({
-      issuer: 'dynamo-bot',
-    });
-
-    // Try to find conversation by name or platformChannelId
-    const conversation: DyFM_Msg_Conversation = await conversationService.dataDBService.findOne({
-      $or: [
-        { name: name },
-        { platformChannelId: name }
-      ],
-      __deleted: { $exists: false }
-    });
-
-    if (!conversation) {
-      throw new Error(`No conversation found with name "${name}"`);
-    }
-
-    this.channelCache.set(name, conversation);
-    return await this.wrapChannel(conversation);
-  }
-
-  async getChannelById(id: string): Promise<DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>> {
-    if (this.channelCache.has(id)) {
-      return await this.wrapChannel(this.channelCache.get(id));
-    }
-
-    const conversationService: DyNTS_Msg_Conversation_DataService = new DyNTS_Msg_Conversation_DataService({
-      issuer: 'dynamo-bot',
-    });
-
-    const conversation: DyFM_Msg_Conversation = await conversationService.dataDBService.findOne({
-      _id: id,
-      __deleted: { $exists: false }
-    });
-
-    if (!conversation) {
-      throw new Error(`No conversation found with ID "${id}"`);
-    }
-
-    this.channelCache.set(id, conversation);
-    return await this.wrapChannel(conversation);
-  }
-
-  async sendMessageToChannel(channel: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>, message: string, issuer: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
-    const msg: DyFM_Msg_Message = await this.messaging_CS.sendMessage(channel.id, { content: message }, this.botId, issuer);
-
-    return await this.wrapMessage(msg);
-  }
-
-  async sendMessageToChannelByName(channelName: string, message: string, issuer: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
-    const channel: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
-    return this.sendMessageToChannel(channel, message, issuer);
-  }
-
-  async getMessagesFromChannelByChannelName(channelName: string, limit: number = 100): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[]> {
-    const channel: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
-    return this.fetchMessages(channel, limit);
-  }
-
-  async getLastMessageInChannel(channelName: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
-    const channel: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
-    const messages: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[] = await this.fetchMessages(channel, 1);
-    return messages.length > 0 ? messages[0] : null;
-  }
-
-  async clearChannel(channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>): Promise<void> {
-    // For messaging system, we don't actually delete messages
-    // This could be implemented to mark messages as deleted or archived
-    DyFM_Log.warn('Clear channel not implemented for messaging system');
-  }
-
-  async replyToMessage(messageWrapper: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>, content: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
-    // In messaging system, we can't directly reply to a message
-    // Instead, we'll send a new message with reference to the original
-    const replyContent: string = `[Reply to message ${messageWrapper.id}] ${content}`;
-    
-    const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(messageWrapper.channelName);
-    return this.sendMessageToChannel(channelWrapper, replyContent, messageWrapper.issuer);
-  }
-
-  async sendTyping(channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>): Promise<void> {
-    // Typing indicators not implemented for messaging system
-    DyFM_Log.info('Typing indicator not supported in messaging system');
-  }
-
-  async sendTypingForMessage(messageWrapper: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>): Promise<void> {
-    // Typing indicators not implemented for messaging system
-    DyFM_Log.info('Typing indicator not supported in messaging system');
-  }
-
-  async fetchMessages(channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>, limit: number): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[]> {
-    const messageService: DyNTS_Msg_Message_DataService = new DyNTS_Msg_Message_DataService({
-      issuer: 'dynamo-bot',
-    });
-
-    const messages: DyFM_Msg_Message[] = await messageService.dataDBService.find({
-      conversationId: channelWrapper.id,
-      __deleted: { $exists: false },
-      $sort: { sentAt: -1 },
-      $limit: limit
-    });
-
-    return await DyFM_Array.asyncMap(messages, async (msg: DyFM_Msg_Message) => await this.wrapMessage(msg));
-  }
-
-  async fetchMessagesById(id: string, limit: number): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[]> {
-    const messageService: DyNTS_Msg_Message_DataService = new DyNTS_Msg_Message_DataService({
-      issuer: 'dynamo-bot',
-    });
-
-    const messages: DyFM_Msg_Message[] = await messageService.dataDBService.find({
-      _id: id,
-      __deleted: { $exists: false },
-      $sort: { sentAt: -1 },
-      $limit: limit
-    });
-
-    return await DyFM_Array.asyncMap(messages, async (msg: DyFM_Msg_Message) => await this.wrapMessage(msg));
-  }
-
-  async fetchMessagesForMessage(messageWrapper: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>, limit: number): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[]> {
-    const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(messageWrapper.channelName);
-    return this.fetchMessages(channelWrapper, limit);
-  }
-
-  async fetchAllMessagesWithPaging(channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>, maxFetch: number = 1000): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[]> {
-    return this.fetchMessages(channelWrapper, maxFetch);
-  }
-
-  async deleteMessage(messageWrapper: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>): Promise<void> {
-    await this.messaging_CS.deleteMessage(messageWrapper.id, 'dynamo-bot', 'dynamo-bot');
-  }
-
-  async updateMessage(message: DyFM_Msg_Message, issuer: string): Promise<void> {
-    await this.messaging_CS.modifyMessage(message, issuer);
-  }
-
-  // User operations
-  async getUserByName(username: string): Promise<DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>> {
-    // In messaging system, we don't have a direct user lookup by name
-    // This would need to be implemented based on your user management system
-    const userData: any = {
-      userId: username,
-      username: username,
-      displayName: username,
-      isBot: false,
-      role: 'member',
-      joinedAt: new Date()
-    };
-
-    return await this.wrapUser(userData);
-  }
-
-  getUserMention(userId: string): string {
-    return `@${userId}`;
-  }
-
-  async readMembersInChannel(channelName: string): Promise<DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>[]> {
-    const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
-    const participants: DyFM_Msg_Participant[] = channelWrapper.rawPlatformChannel.participants || [];
-    
-    return await DyFM_Array.asyncMap(participants, async (participant: DyFM_Msg_Participant) => await this.wrapUser(participant));
-  }
-
-  async readMemberNamesInChannel(channelName: string): Promise<string[]> {
-    const members: DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>[] = await this.readMembersInChannel(channelName);
-    return members.map(member => member.username);
-  }
-
-  // Advanced message queries
-  async getLastMessageSentBy(channelName: string, username: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
-    const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
-    const messages: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[] = await this.fetchAllMessagesWithPaging(channelWrapper, 1000);
-    
-    return messages.find(msg => msg.authorName === username) || null;
-  }
-
-  async getLastMentionOf(channelName: string, username: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
-    const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
-    const messages: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[] = await this.fetchAllMessagesWithPaging(channelWrapper, 1000);
-    
-    return messages.find(msg => 
-      msg.content.includes(`@${username}`) || 
-      msg.content.includes(username)
-    ) || null;
-  }
-
-  async readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<DyNTS_Bot_LastMessageDate[]> {
-    const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
-    const messages: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[] = await this.fetchAllMessagesWithPaging(channelWrapper, 1000);
-    
-    const memberStatus: Record<string, { lastMessageDate: Date | null, allMessages: number }> = {};
-    memberNames.forEach((name: string) => {
-      memberStatus[name] = { lastMessageDate: null, allMessages: 0 };
-    });
-
-    const cutoffTime: number = Date.now() - (3 * week); // 3 weeks
-
-    messages.forEach((message: DyNTS_DyB_Message) => {
-      if (message.timestamp < cutoffTime) return;
-
-      const author = message.authorName;
-      if (memberStatus[author] !== undefined) {
-        memberStatus[author].allMessages++;
-        if (!memberStatus[author].lastMessageDate) {
-          memberStatus[author].lastMessageDate = new Date(message.timestamp);
-        }
-      }
-    });
-
-    return memberNames.map((memberName: string) => {
-      const status: { lastMessageDate: Date | null, allMessages: number } = memberStatus[memberName];
-      return {
-        memberName: memberName,
-        allMessages: status.allMessages,
-        lastMessageDate: status.lastMessageDate
-      };
-    });
-  }
-
-  async readLastMessageWithMemberNamePingInIt(channelName: string, users: DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>[]): Promise<DyNTS_Bot_LastMentionDate[]> {
-    const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
-    const messages: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[] = await this.fetchAllMessagesWithPaging(channelWrapper, 1000);
-    
-    const memberStatus: Record<string, { lastMentionDate: Date | null; allMentions: number }> = {};
-    users.forEach((user: DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>) => {
-      memberStatus[user.username] = { lastMentionDate: null, allMentions: 0 };
-    });
-
-    const cutoffTime: number = Date.now() - (3 * week); // 3 weeks
-
-    messages.forEach((message: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>) => {
-      if (message.timestamp < cutoffTime) return;
-
-      users.forEach((user: DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>) => {
-        if (
-          message.content.includes(`@${user.id}`) && 
-          !memberStatus[user.username].lastMentionDate
-        ) {
-          memberStatus[user.username].lastMentionDate = new Date(message.timestamp);
-          memberStatus[user.username].allMentions++;
-        }
-      });
-    });
-
-    return users.map((user: DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>) => {
-      const status: { lastMentionDate: Date | null; allMentions: number } = memberStatus[user.username];
-      return {
-        memberId: user.id,
-        memberName: user.username,
-        allMentions: status.allMentions,
-        lastMentionDate: status.lastMentionDate
-      };
-    });
-  }
-
-  // Platform-specific features (not applicable for messaging system)
-  getRoleByName?(roleName: string): any {
-    return null; // Not applicable for messaging system
-  }
-
-  getRolePingByName?(roleName: string): Promise<string> {
-    return Promise.resolve(''); // Not applicable for messaging system
-  }
-
-  getRolePingsByName?(roleNames: string[]): Promise<string> {
-    return Promise.resolve(''); // Not applicable for messaging system
-  }
-
-  // Event binding
-  async create_onMessageEventListener(
-    handler: (message: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>, issuer: string) => Promise<void>
-  ): Promise<void> {
-    // TODO: Implement message event listener for messaging system
-    DyFM_Log.info('Message event listener created (messaging integration)');
-  }
-
-  create_onErrorEventListener(handler: (error: DyFM_AnyError) => void): void {
-    // TODO: Implement error event listener for messaging system
-    DyFM_Log.info('Error event listener created (messaging integration)');
-  }
-
-  async sendReport(message: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
-    return await this.sendMessageToChannelByName(this.config.reportChannelName, message, 'dynamo-bot');
-  }
-
-  async sendReportIn(message: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
-    return await this.sendMessageToChannelByName(
-      this.config.reportChannelName, 
-      `${this.botDisplayName} report for duty! ` +
-        `(v${DyNTS_global_settings.systemVersion} ${DyNTS_global_settings.env_settings?.environment})`,
-      'dynamo-bot'
-    );
-  }
-
-  async wrapMessage(msgMessage: DyFM_Msg_Message): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
-    return new DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>({
-      id: msgMessage._id,
-      content: msgMessage.content,
-      authorId: msgMessage.senderId,
-      authorName: msgMessage.senderName,
-      authorDisplayName: msgMessage.senderDisplayName,
-      channelId: msgMessage.conversationId,
-      channelName: msgMessage.conversationId,
-      timestamp: msgMessage.sentAt ? new Date(msgMessage.sentAt).getTime() : Date.now(),
-      isBot: msgMessage.isAIGenerated || false,
-      isTextBased: true,
-      isVoiceBased: false,
-      isDM: false,
-      replyToMessageId: msgMessage.parentMessageId,
-      replyToMessageAuthorId: null,
-      mentions: msgMessage.mentions.map(mention => mention.userId),
-      rawPlatformMessage: msgMessage,
-
-      issuer: msgMessage.senderId,
-
-      /* channel: this.wrapChannel(msgMessage.conversation), */
-      channel: null,
-      /* user: this.wrapUser(msgMessage.sender), */
-
-      provider: this,
-    });
-  }
-
-  async wrapChannel(conversation: DyFM_Msg_Conversation): Promise<DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>> {
-    return new DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>({
-      id: conversation._id,
-      name: conversation.title || conversation.platformChannelId || 'unknown',
-      isTextBased: true,
-      isDM: conversation.type === 'direct',
-      isVoiceBased: false,
-      rawPlatformChannel: conversation,
-      provider: this
-    });
-  }
-
-  async wrapUser(user: DyFM_Msg_Participant): Promise<DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>> {
-    return new DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>({
-      id: user.userId,
-      username: user.username,
-      displayName: user.displayName,
-      isBot: false,
-      rawPlatformUser: user,
-      provider: this
-    });
-  }
-}
+import { DyFM_AnyError, DyFM_Array, DyFM_Error, DyFM_Log, week } from '@futdevpro/fsm-dynamo';
+import { 
+  DyFM_Msg_Provider_Type, DyFM_Msg_Conversation, DyFM_Msg_EventKey, DyFM_Msg_Message, DyFM_Msg_Participant 
+} from '@futdevpro/fsm-dynamo/messaging';
+
+import { 
+  DyNTS_Bot_MessagingProvider_ServiceBase, DyNTS_Bot_MessagingProvider_Config 
+} 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_MessageWrapper } from '../../../_models/bot-message-wrapper.interface';
+import { DyNTS_Bot_UserWrapper } from '../../../_models/bot-user-wrapper.interface';
+import { DyNTS_DyB_Message, DyNTS_DyB_Channel, DyNTS_DyB_User } from '../_models/dyb-platform.types';
+import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
+import { DyNTS_Msg_Main_ControlService } from '../../../../messaging/_services/msg-main.control-service';
+import { DyNTS_Msg_Message_DataService } from '../../../../messaging/_services/msg-message.data-service';
+import { DyNTS_Msg_Conversation_DataService } from '../../../../messaging/_services/msg-conversation.data-service';
+import { DyNTS_Msg_Events_Service } from '../../../../messaging/_services/msg-events.service';
+
+export interface Dynamo_MessagingProviderConfig extends DyNTS_Bot_MessagingProvider_Config {
+  botUserId?: string;
+  botDisplayName?: string;
+}
+
+export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_MessagingProvider_ServiceBase<
+  DyFM_Msg_Conversation,
+  DyFM_Msg_Message,
+  DyFM_Msg_Participant,
+  Dynamo_MessagingProviderConfig,
+  any
+> {
+  readonly name = 'dynamo';
+  readonly type = DyFM_Msg_Provider_Type.dynamo;
+
+  get botId(): string {
+    return this.config.botUserId || 'dynamo-bot';
+  }
+
+  get botDisplayName(): string {
+    return this.config.botDisplayName || 'Dynamo Bot';
+  }
+  
+  readonly config: Dynamo_MessagingProviderConfig;
+
+  /* protected override readonly channelCache: Map<string, DyFM_Msg_Conversation> = new Map();
+  protected override readonly roleCache: Map<string, any> = new Map(); */
+
+  // Services
+  private messaging_CS: DyNTS_Msg_Main_ControlService;
+  private eventsService: DyNTS_Msg_Events_Service;
+
+  constructor(setConfig: Dynamo_MessagingProviderConfig) {
+    super();
+    this.config = setConfig;
+    this.messaging_CS = DyNTS_Msg_Main_ControlService.getInstance();
+    this.eventsService = DyNTS_Msg_Events_Service.getInstance();
+  }
+
+  async setup(issuer: string): Promise<void> {
+    try {
+      DyFM_Log.success('Dynamo bot provider setup completed');
+    } catch (error) {   
+      DyFM_Error.logSimple('Error during Dynamo bot setup:', error);
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('setup', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DyB-MessagingProvider-S000`,
+      });
+    }
+  }
+
+  async start(issuer: string): Promise<void> {
+    try {
+      // Setup event listeners for messaging events
+      this.setupEventListeners();
+      DyFM_Log.success('Dynamo bot provider started');
+    } catch (error) {
+      DyFM_Error.logSimple('Error during Dynamo bot start:', error);
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('start', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DyB-MessagingProvider-S001`,
+      });
+    }
+  }
+
+  private setupEventListeners(): void {
+    // Listen to messaging events and convert them to bot events
+    // Note: This would require extending the events service to support custom listeners
+    // For now, we'll implement a basic approach
+    DyFM_Log.info('Dynamo bot event listeners setup (messaging integration)');
+  }
+
+  // Channel operations
+  async getChannelByName(name: string): Promise<DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>> {
+    if (this.channelCache.has(name)) {
+      return await this.wrapChannel(this.channelCache.get(name));
+    }
+
+    const conversationService: DyNTS_Msg_Conversation_DataService = new DyNTS_Msg_Conversation_DataService({
+      issuer: 'dynamo-bot',
+    });
+
+    // Try to find conversation by name or platformChannelId
+    const conversation: DyFM_Msg_Conversation = await conversationService.dataDBService.findOne({
+      $or: [
+        { name: name },
+        { platformChannelId: name }
+      ],
+      __deleted: { $exists: false }
+    });
+
+    if (!conversation) {
+      throw new Error(`No conversation found with name "${name}"`);
+    }
+
+    this.channelCache.set(name, conversation);
+    return await this.wrapChannel(conversation);
+  }
+
+  async getChannelById(id: string): Promise<DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>> {
+    if (this.channelCache.has(id)) {
+      return await this.wrapChannel(this.channelCache.get(id));
+    }
+
+    const conversationService: DyNTS_Msg_Conversation_DataService = new DyNTS_Msg_Conversation_DataService({
+      issuer: 'dynamo-bot',
+    });
+
+    const conversation: DyFM_Msg_Conversation = await conversationService.dataDBService.findOne({
+      _id: id,
+      __deleted: { $exists: false }
+    });
+
+    if (!conversation) {
+      throw new Error(`No conversation found with ID "${id}"`);
+    }
+
+    this.channelCache.set(id, conversation);
+    return await this.wrapChannel(conversation);
+  }
+
+  async sendMessageToChannel(channel: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>, message: string, issuer: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
+    const msg: DyFM_Msg_Message = await this.messaging_CS.sendMessage(channel.id, { content: message }, this.botId, issuer);
+
+    return await this.wrapMessage(msg);
+  }
+
+  async sendMessageToChannelByName(channelName: string, message: string, issuer: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
+    const channel: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
+    return this.sendMessageToChannel(channel, message, issuer);
+  }
+
+  async getMessagesFromChannelByChannelName(channelName: string, limit: number = 100): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[]> {
+    const channel: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
+    return this.fetchMessages(channel, limit);
+  }
+
+  async getLastMessageInChannel(channelName: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
+    const channel: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
+    const messages: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[] = await this.fetchMessages(channel, 1);
+    return messages.length > 0 ? messages[0] : null;
+  }
+
+  async clearChannel(channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>): Promise<void> {
+    // For messaging system, we don't actually delete messages
+    // This could be implemented to mark messages as deleted or archived
+    DyFM_Log.warn('Clear channel not implemented for messaging system');
+  }
+
+  async replyToMessage(messageWrapper: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>, content: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
+    // In messaging system, we can't directly reply to a message
+    // Instead, we'll send a new message with reference to the original
+    const replyContent: string = `[Reply to message ${messageWrapper.id}] ${content}`;
+    
+    const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(messageWrapper.channelName);
+    return this.sendMessageToChannel(channelWrapper, replyContent, messageWrapper.issuer);
+  }
+
+  async sendTyping(channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>): Promise<void> {
+    // Typing indicators not implemented for messaging system
+    DyFM_Log.info('Typing indicator not supported in messaging system');
+  }
+
+  async sendTypingForMessage(messageWrapper: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>): Promise<void> {
+    // Typing indicators not implemented for messaging system
+    DyFM_Log.info('Typing indicator not supported in messaging system');
+  }
+
+  async fetchMessages(channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>, limit: number): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[]> {
+    const messageService: DyNTS_Msg_Message_DataService = new DyNTS_Msg_Message_DataService({
+      issuer: 'dynamo-bot',
+    });
+
+    const messages: DyFM_Msg_Message[] = await messageService.dataDBService.find({
+      conversationId: channelWrapper.id,
+      __deleted: { $exists: false },
+      $sort: { sentAt: -1 },
+      $limit: limit
+    });
+
+    return await DyFM_Array.asyncMap(messages, async (msg: DyFM_Msg_Message) => await this.wrapMessage(msg));
+  }
+
+  async fetchMessagesById(id: string, limit: number): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[]> {
+    const messageService: DyNTS_Msg_Message_DataService = new DyNTS_Msg_Message_DataService({
+      issuer: 'dynamo-bot',
+    });
+
+    const messages: DyFM_Msg_Message[] = await messageService.dataDBService.find({
+      _id: id,
+      __deleted: { $exists: false },
+      $sort: { sentAt: -1 },
+      $limit: limit
+    });
+
+    return await DyFM_Array.asyncMap(messages, async (msg: DyFM_Msg_Message) => await this.wrapMessage(msg));
+  }
+
+  async fetchMessagesForMessage(messageWrapper: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>, limit: number): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[]> {
+    const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(messageWrapper.channelName);
+    return this.fetchMessages(channelWrapper, limit);
+  }
+
+  async fetchAllMessagesWithPaging(channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>, maxFetch: number = 1000): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[]> {
+    return this.fetchMessages(channelWrapper, maxFetch);
+  }
+
+  async deleteMessage(messageWrapper: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>): Promise<void> {
+    await this.messaging_CS.deleteMessage(messageWrapper.id, 'dynamo-bot', 'dynamo-bot');
+  }
+
+  async updateMessage(message: DyFM_Msg_Message, issuer: string): Promise<void> {
+    await this.messaging_CS.modifyMessage(message, issuer);
+  }
+
+  // User operations
+  async getUserByName(username: string): Promise<DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>> {
+    // In messaging system, we don't have a direct user lookup by name
+    // This would need to be implemented based on your user management system
+    const userData: any = {
+      userId: username,
+      username: username,
+      displayName: username,
+      isBot: false,
+      role: 'member',
+      joinedAt: new Date()
+    };
+
+    return await this.wrapUser(userData);
+  }
+
+  getUserMention(userId: string): string {
+    return `@${userId}`;
+  }
+
+  async readMembersInChannel(channelName: string): Promise<DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>[]> {
+    const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
+    const participants: DyFM_Msg_Participant[] = channelWrapper.rawPlatformChannel.participants || [];
+    
+    return await DyFM_Array.asyncMap(participants, async (participant: DyFM_Msg_Participant) => await this.wrapUser(participant));
+  }
+
+  async readMemberNamesInChannel(channelName: string): Promise<string[]> {
+    const members: DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>[] = await this.readMembersInChannel(channelName);
+    return members.map(member => member.username);
+  }
+
+  // Advanced message queries
+  async getLastMessageSentBy(channelName: string, username: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
+    const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
+    const messages: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[] = await this.fetchAllMessagesWithPaging(channelWrapper, 1000);
+    
+    return messages.find(msg => msg.authorName === username) || null;
+  }
+
+  async getLastMentionOf(channelName: string, username: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
+    const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
+    const messages: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[] = await this.fetchAllMessagesWithPaging(channelWrapper, 1000);
+    
+    return messages.find(msg => 
+      msg.content.includes(`@${username}`) || 
+      msg.content.includes(username)
+    ) || null;
+  }
+
+  async readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<DyNTS_Bot_LastMessageDate[]> {
+    const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
+    const messages: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[] = await this.fetchAllMessagesWithPaging(channelWrapper, 1000);
+    
+    const memberStatus: Record<string, { lastMessageDate: Date | null, allMessages: number }> = {};
+    memberNames.forEach((name: string) => {
+      memberStatus[name] = { lastMessageDate: null, allMessages: 0 };
+    });
+
+    const cutoffTime: number = Date.now() - (3 * week); // 3 weeks
+
+    messages.forEach((message: DyNTS_DyB_Message) => {
+      if (message.timestamp < cutoffTime) return;
+
+      const author = message.authorName;
+      if (memberStatus[author] !== undefined) {
+        memberStatus[author].allMessages++;
+        if (!memberStatus[author].lastMessageDate) {
+          memberStatus[author].lastMessageDate = new Date(message.timestamp);
+        }
+      }
+    });
+
+    return memberNames.map((memberName: string) => {
+      const status: { lastMessageDate: Date | null, allMessages: number } = memberStatus[memberName];
+      return {
+        memberName: memberName,
+        allMessages: status.allMessages,
+        lastMessageDate: status.lastMessageDate
+      };
+    });
+  }
+
+  async readLastMessageWithMemberNamePingInIt(channelName: string, users: DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>[]): Promise<DyNTS_Bot_LastMentionDate[]> {
+    const channelWrapper: DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> = await this.getChannelByName(channelName);
+    const messages: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>[] = await this.fetchAllMessagesWithPaging(channelWrapper, 1000);
+    
+    const memberStatus: Record<string, { lastMentionDate: Date | null; allMentions: number }> = {};
+    users.forEach((user: DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>) => {
+      memberStatus[user.username] = { lastMentionDate: null, allMentions: 0 };
+    });
+
+    const cutoffTime: number = Date.now() - (3 * week); // 3 weeks
+
+    messages.forEach((message: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>) => {
+      if (message.timestamp < cutoffTime) return;
+
+      users.forEach((user: DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>) => {
+        if (
+          message.content.includes(`@${user.id}`) && 
+          !memberStatus[user.username].lastMentionDate
+        ) {
+          memberStatus[user.username].lastMentionDate = new Date(message.timestamp);
+          memberStatus[user.username].allMentions++;
+        }
+      });
+    });
+
+    return users.map((user: DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>) => {
+      const status: { lastMentionDate: Date | null; allMentions: number } = memberStatus[user.username];
+      return {
+        memberId: user.id,
+        memberName: user.username,
+        allMentions: status.allMentions,
+        lastMentionDate: status.lastMentionDate
+      };
+    });
+  }
+
+  // Platform-specific features (not applicable for messaging system)
+  getRoleByName?(roleName: string): any {
+    return null; // Not applicable for messaging system
+  }
+
+  getRolePingByName?(roleName: string): Promise<string> {
+    return Promise.resolve(''); // Not applicable for messaging system
+  }
+
+  getRolePingsByName?(roleNames: string[]): Promise<string> {
+    return Promise.resolve(''); // Not applicable for messaging system
+  }
+
+  // Event binding
+  async create_onMessageEventListener(
+    handler: (message: DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>, issuer: string) => Promise<void>
+  ): Promise<void> {
+    // TODO: Implement message event listener for messaging system
+    DyFM_Log.info('Message event listener created (messaging integration)');
+  }
+
+  create_onErrorEventListener(handler: (error: DyFM_AnyError) => void): void {
+    // TODO: Implement error event listener for messaging system
+    DyFM_Log.info('Error event listener created (messaging integration)');
+  }
+
+  async sendReport(message: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
+    return await this.sendMessageToChannelByName(this.config.reportChannelName, message, 'dynamo-bot');
+  }
+
+  async sendReportIn(message: string): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
+    return await this.sendMessageToChannelByName(
+      this.config.reportChannelName, 
+      `${this.botDisplayName} report for duty! ` +
+        `(v${DyNTS_global_settings.systemVersion} ${DyNTS_global_settings.env_settings?.environment})`,
+      'dynamo-bot'
+    );
+  }
+
+  async wrapMessage(msgMessage: DyFM_Msg_Message): Promise<DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>> {
+    return new DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>({
+      id: msgMessage._id,
+      content: msgMessage.content,
+      authorId: msgMessage.senderId,
+      authorName: msgMessage.senderName,
+      authorDisplayName: msgMessage.senderDisplayName,
+      channelId: msgMessage.conversationId,
+      channelName: msgMessage.conversationId,
+      timestamp: msgMessage.sentAt ? new Date(msgMessage.sentAt).getTime() : Date.now(),
+      isBot: msgMessage.isAIGenerated || false,
+      isTextBased: true,
+      isVoiceBased: false,
+      isDM: false,
+      replyToMessageId: msgMessage.parentMessageId,
+      replyToMessageAuthorId: null,
+      mentions: msgMessage.mentions.map(mention => mention.userId),
+      rawPlatformMessage: msgMessage,
+
+      issuer: msgMessage.senderId,
+
+      /* channel: this.wrapChannel(msgMessage.conversation), */
+      channel: null,
+      /* user: this.wrapUser(msgMessage.sender), */
+
+      provider: this,
+    });
+  }
+
+  async wrapChannel(conversation: DyFM_Msg_Conversation): Promise<DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>> {
+    return new DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>({
+      id: conversation._id,
+      name: conversation.title || conversation.platformChannelId || 'unknown',
+      isTextBased: true,
+      isDM: conversation.type === 'direct',
+      isVoiceBased: false,
+      rawPlatformChannel: conversation,
+      provider: this
+    });
+  }
+
+  async wrapUser(user: DyFM_Msg_Participant): Promise<DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>> {
+    return new DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>({
+      id: user.userId,
+      username: user.username,
+      displayName: user.displayName,
+      isBot: false,
+      rawPlatformUser: user,
+      provider: this
+    });
+  }
+}