@futdevpro/nts-dynamo 1.14.29 → 1.14.32

package/src/_modules/bot/_modules/discord-bot/_services/dib-messaging-provider.control-service.ts

@@ -0,0 +1,529 @@
+import { Client, GatewayIntentBits, Guild, Collection, GuildMember, Message, Partials, Role, TextChannel, Channel, DMChannel } from 'discord.js';
+import { DyFM_AnyError, DyFM_Error, DyFM_Log, week } from '@futdevpro/fsm-dynamo';
+import { DyNTS_Bot_MessagingProvider_ServiceBase, DyNTS_Bot_MessagingProvider_Config } from '../../../_services/bot-messaging-provider.service-base';
+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_global_settings } from '../../../../../_collections/global-settings.const';
+import { DyNTS_Bot_ChannelWrapper } from '../../../_models/bot-channel-wrapper.interface';
+import { DyNTS_Bot_MessageWrapper } from '../../../_models/bot-message-wrapper.interface';
+import { DyNTS_Bot_UserWrapper } from '../../../_models/bot-user-wrapper.interface';
+
+export type DyNTS_DiB_Message = DyNTS_Bot_MessageWrapper<Message>;
+export type DyNTS_DiB_Channel = DyNTS_Bot_ChannelWrapper<Channel>;
+export type DyNTS_DiB_User = DyNTS_Bot_UserWrapper<GuildMember>;
+
+export interface Discord_MessagingProviderConfig extends DyNTS_Bot_MessagingProvider_Config {
+  token: string;
+  guildId: string;
+  clientId: string;
+  oauth2Url: string;
+  intents: GatewayIntentBits[];
+  partials: Partials[];
+}
+
+export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_MessagingProvider_ServiceBase<
+  Channel,
+  Message,
+  GuildMember,
+  Discord_MessagingProviderConfig,
+  Role
+> {
+  readonly name = 'discord';
+  readonly type = DyNTS_Bot_MessagingProvider_Type.discord;
+
+  get botId(): string {
+    return this.client.user?.id;
+  }
+
+  get botDisplayName(): string {
+    return this.client.user?.displayName;
+  }
+  
+  override readonly config: Discord_MessagingProviderConfig;
+
+  private client: Client;
+  private guild: Guild;
+
+  constructor(
+    setConfig: Discord_MessagingProviderConfig
+  ) {
+    super();
+
+    this.config = setConfig;
+  }
+
+  // Public accessors for Discord-specific objects (for backward compatibility with CCAP)
+  get discordClient(): Client {
+    return this.client;
+  }
+
+  get discordGuild(): Guild {
+    return this.guild;
+  }
+
+  async setup(issuer: string): Promise<void> {
+    try {
+      this.client = new Client({
+        intents: this.config.intents,
+        partials: this.config.partials,
+      });
+
+    } catch (error) {   
+      DyFM_Error.logSimple('Error during Discord bot setup:', error);
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('setup', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiB-MessagingProvider-S000`,
+      });
+    }
+  }
+
+  async start(issuer: string): Promise<void> {
+    try {
+      if (!this.client) {
+        throw new Error('Discord client not initialized. Call setup() first.');
+      }
+
+      return new Promise((resolve, reject) => {
+        this.client.on('ready', async () => {
+          if (DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
+            DyFM_Log.success(`Discord bot logged in as ${this.client.user?.tag}`);
+          }
+
+          // Get guild
+          this.guild = this.client.guilds.cache.get(this.config.guildId);
+          if (!this.guild) {
+            reject(new Error(`Discord server not found with ID: ${this.config.guildId}`));
+            return;
+          }
+
+          resolve();
+        });
+
+        this.client.login(this.config.token).catch(reject);
+      });
+    } catch (error) {
+      DyFM_Error.logSimple('Error during Discord bot start:', error);
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('start', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiB-MessagingProvider-S001`,
+      });
+    }
+  }
+
+  async getChannelByName(name: string): Promise<DyNTS_DiB_Channel> {
+    if (this.channelCache.has(name)) {
+      return this.wrapChannel(this.channelCache.get(name));
+    }
+
+    const channel = this.guild.channels.cache.find(
+      (ch) => ch.name === name && ch.isTextBased()
+    ) as TextChannel;
+
+    if (!channel) {
+      throw new Error(`No text channel found with name "${name}"`);
+    }
+
+    this.channelCache.set(name, channel);
+    return this.wrapChannel(channel);
+  }
+
+  async getChannelById(id: string): Promise<DyNTS_DiB_Channel> {
+    const channel = this.guild.channels.cache.get(id) as TextChannel;
+    if (!channel) {
+      throw new Error(`No text channel found with ID "${id}"`);
+    }
+
+    if (!this.channelCache.has(channel.name)) {
+      this.channelCache.set(channel.name, channel);
+    }
+    return this.wrapChannel(channel);
+  }
+
+  async sendMessageToChannelByName(channelName: string, message: string): Promise<DyNTS_DiB_Message> {
+    const discordChannel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
+
+    if (!discordChannel.rawPlatformChannel.isTextBased()) {
+      throw new Error(`Channel "${channelName}" is not a text channel`);
+    }
+
+    const sentMessage: Message = await (discordChannel.rawPlatformChannel as TextChannel).send(message);
+
+    return this.wrapMessage(sentMessage);
+  }
+
+  async getMessagesFromChannelByChannelName(channelName: string, limit: number = 100): Promise<DyNTS_DiB_Message[]> {
+    const channel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
+
+    if (!channel.rawPlatformChannel.isTextBased()) {
+      throw new Error(`Channel "${channelName}" is not a text channel`);
+    }
+
+    const messages: Collection<string, Message> = await (channel.rawPlatformChannel as TextChannel).messages.fetch({ 
+      limit: limit
+    });
+
+    return Array.from(messages.values()).map((msg: Message) => this.wrapMessage(msg));
+  }
+
+  async getLastMessageInChannel(channelName: string): Promise<DyNTS_DiB_Message> {
+    const channel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
+
+    if (!channel.rawPlatformChannel.isTextBased()) {
+      throw new Error(`Channel "${channelName}" is not a text channel`);
+    }
+
+    const messages: Collection<string, Message> = await (channel.rawPlatformChannel as TextChannel).messages.fetch({ 
+      limit: 1 
+    });
+    const lastMessage: Message = messages.first();
+
+    return lastMessage ? this.wrapMessage(lastMessage) : null;
+  }
+
+  async clearChannel(channel: DyNTS_DiB_Channel): Promise<void> {
+    if (!channel.rawPlatformChannel.isTextBased()) {
+      throw new Error(`Channel "${channel.name}" is not a text channel`);
+    }
+
+    let lastId: string | undefined = undefined;
+    let fetched: number = 0;
+    const maxFetch: number = 1000;
+
+    while (fetched < maxFetch) {
+      const options: { limit: number; before?: string } = { limit: 100 };
+      if (lastId) {
+        options.before = lastId;
+      }
+
+      const messageCollection: Collection<string, Message> = await channel.rawPlatformChannel.messages.fetch(options);
+      if (messageCollection.size === 0) {
+        break;
+      }
+
+      const deletePromises = Array.from(messageCollection.values()).map((message: Message) => 
+        message.delete().catch((error) => {
+          DyFM_Error.logSimple('Failed to delete message', error);
+        })
+      );
+
+      await Promise.all(deletePromises);
+      lastId = Array.from(messageCollection.values()).pop()?.id;
+      fetched += messageCollection.size;
+    }
+  }
+
+  // Message operations
+  async sendMessage(channel: DyNTS_DiB_Channel, content: string): Promise<DyNTS_DiB_Message> {
+    if (!channel.rawPlatformChannel.isTextBased()) {
+      throw new Error(`Channel "${channel.name}" is not a text channel`);
+    }
+
+    const message: Message = await (channel.rawPlatformChannel as TextChannel).send(content);
+    return this.wrapMessage(message);
+  }
+
+  async replyToMessage(message: DyNTS_DiB_Message, content: string): Promise<DyNTS_DiB_Message> {
+    /* const channel = this.guild.channels.cache.get(channelId) as TextChannel;
+    if (!channel) {
+      throw new Error(`Channel not found with ID: ${channelId}`);
+    }
+    const message = await channel.messages.fetch(messageId); */
+    if (!message.rawPlatformMessage.channel.isTextBased()) {
+      throw new Error(`Message "${message.id}" is not a text message`);
+    }
+
+    const reply: Message= await message.rawPlatformMessage.reply(content);
+    return this.wrapMessage(reply);
+  }
+
+  async sendTyping(channel: DyNTS_DiB_Channel): Promise<void> {
+    if (!channel.rawPlatformChannel.isTextBased()) {
+      throw new Error(`Channel "${channel.name}" is not a text channel`);
+    }
+
+    await (channel.rawPlatformChannel as TextChannel).sendTyping();
+  }
+
+  async sendTypingForMessage(message: DyNTS_DiB_Message): Promise<void> {
+    if (!message.rawPlatformMessage.channel.isTextBased()) {
+      throw new Error(`Message "${message.id}" is not a text message`);
+    }
+
+    await (message.rawPlatformMessage.channel as TextChannel).sendTyping();
+  }
+
+  async fetchMessages(channel: DyNTS_DiB_Channel, limit: number): Promise<DyNTS_DiB_Message[]> {
+    if (!channel.rawPlatformChannel.isTextBased()) {
+      throw new Error(`Channel "${channel.name}" is not a text channel`);
+    }
+
+    const messages: Collection<string, Message> = await (channel.rawPlatformChannel as TextChannel).messages.fetch({ 
+      limit: limit
+    });
+    return Array.from(messages.values()).map((msg: Message) => this.wrapMessage(msg));
+  }
+
+  async fetchMessagesById(id: string, limit: number): Promise<DyNTS_DiB_Message[]> {
+    const channel: DyNTS_DiB_Channel = await this.getChannelById(id);
+    return this.fetchMessages(channel, limit);
+  }
+
+  async fetchMessagesForMessage(message: DyNTS_DiB_Message, limit: number): Promise<DyNTS_DiB_Message[]> {
+    if (!message.rawPlatformMessage.channel.isTextBased()) {
+      throw new Error(`Message "${message.id}" is not a text message`);
+    }
+
+    const messages: Collection<string, Message> = await message.rawPlatformMessage.channel.messages.fetch({ 
+      limit: limit
+    });
+    return Array.from(messages.values()).map((msg: Message) => this.wrapMessage(msg));
+  }
+
+  async fetchAllMessagesWithPaging(channel: DyNTS_DiB_Channel, maxFetch: number = 1000): Promise<DyNTS_DiB_Message[]> {
+    if (!channel.rawPlatformChannel.isTextBased()) {
+      throw new Error(`Channel "${channel.name}" is not a text channel`);
+    }
+
+    let lastId: string | undefined = undefined;
+    let fetched: number = 0;
+    const allMessages: DyNTS_DiB_Message[] = [];
+
+    while (fetched < maxFetch) {
+      const options: { limit: number; before?: string } = { limit: 100 };
+      if (lastId) options.before = lastId;
+
+      const messageCollection: Collection<string, Message> = await channel.rawPlatformChannel.messages.fetch(options);
+      if (messageCollection.size === 0) break;
+
+      Array.from(messageCollection.values()).forEach((msg: Message) => {
+        allMessages.push(this.wrapMessage(msg));
+      });
+
+      lastId = Array.from(messageCollection.values()).pop()?.id;
+      fetched += messageCollection.size;
+    }
+
+    return allMessages;
+  }
+
+  async deleteMessage(message: DyNTS_DiB_Message): Promise<void> {
+    await message.rawPlatformMessage.delete();
+  }
+
+  // User operations
+  async getUserByName(username: string): Promise<DyNTS_DiB_User> {
+    const member: GuildMember = this.guild.members.cache.find((m: GuildMember) => m.user.username === username);
+
+    if (!member) {
+      throw new Error(`User not found with username: ${username}`);
+    }
+
+    return this.wrapUser(member);
+  }
+
+  getUserMention(userId: string): string {
+    return `<@${userId}>`;
+  }
+
+  async readMembersInChannel(channelName: string): Promise<DyNTS_DiB_User[]> {
+    const channel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
+    const members: Collection<string, GuildMember> = await this.guild.members.fetch();
+    
+    const allowedMembers: Collection<string, GuildMember> = members.filter((member: GuildMember) =>
+      channel.rawPlatformChannel.isTextBased() &&
+      (channel.rawPlatformChannel as TextChannel).permissionsFor(member)?.has('ViewChannel')
+    );
+
+    return Array.from(allowedMembers.values()).map((member: GuildMember) => this.wrapUser(member));
+  }
+
+  async readMemberNamesInChannel(channelName: string): Promise<string[]> {
+    const members: DyNTS_DiB_User[] = await this.readMembersInChannel(channelName);
+    return members.map((member: DyNTS_DiB_User) => member.username);
+  }
+
+  // Advanced message queries
+  async getLastMessageSentBy(channelName: string, username: string): Promise<DyNTS_DiB_Message> {
+    const channel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
+    const messages: DyNTS_DiB_Message[] = await this.fetchAllMessagesWithPaging(channel, 1000);
+    
+    return messages.find((msg: DyNTS_DiB_Message) => msg.authorName === username) || null;
+  }
+
+  async getLastMentionOf(channelName: string, username: string): Promise<DyNTS_DiB_Message> {
+    const channel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
+    const messages: DyNTS_DiB_Message[] = await this.fetchAllMessagesWithPaging(channel, 1000);
+    
+    return messages.find((msg: DyNTS_DiB_Message) => 
+      msg.content.includes(`@${username}`) || 
+      msg.content.includes(`<@${username}>`)
+    ) || null;
+  }
+
+  // Advanced message queries
+  async readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<DyNTS_Bot_LastMessageDate[]> {
+    const channel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
+    const messages: DyNTS_DiB_Message[] = await this.fetchAllMessagesWithPaging(channel, 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_DiB_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
+      };
+    });
+  }
+
+  // Advanced message queries
+  async readLastMessageWithMemberNamePingInIt(channelName: string, users: DyNTS_DiB_User[]): Promise<DyNTS_Bot_LastMentionDate[]> {
+    const channel: DyNTS_DiB_Channel = await this.getChannelByName(channelName);
+    const messages: DyNTS_DiB_Message[] = await this.fetchAllMessagesWithPaging(channel, 1000);
+    
+    const memberStatus: Record<string, { lastMentionDate: Date | null, allMentions: number }> = {};
+    users.forEach((user: DyNTS_DiB_User) => {
+      memberStatus[user.username] = { lastMentionDate: null, allMentions: 0 };
+    });
+
+    const cutoffTime: number = Date.now() - (3 * week); // 3 weeks
+
+    messages.forEach((message: DyNTS_DiB_Message) => {
+      if (message.timestamp < cutoffTime) return;
+
+      users.forEach((user: DyNTS_DiB_User) => {
+        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_DiB_User) => {
+      const status: { lastMentionDate: Date | null, allMentions: number } = memberStatus[user.username];
+      
+      return {
+        memberId: user.id,
+        memberName: user.username,
+        allMentions: status.allMentions,
+        lastMentionDate: status.lastMentionDate
+      };
+    });
+  }
+
+  // Discord-specific features
+  getRoleByName(roleName: string): Role {
+    if (this.roleCache.has(roleName)) {
+      return this.roleCache.get(roleName);
+    }
+
+    const role: Role = this.guild.roles.cache.find((r: Role) => r.name === roleName);
+    if (role) {
+      this.roleCache.set(roleName, role);
+    }
+    return role;
+  }
+
+  async getRolePingByName(roleName: string): Promise<string> {
+    const role: Role = this.getRoleByName(roleName);
+    return role ? `<@&${role.id}>` : '';
+  }
+
+  async getRolePingsByName(roleNames: string[]): Promise<string> {
+    const pings: string[] = await Promise.all(
+      roleNames.map((roleName: string) => this.getRolePingByName(roleName))
+    );
+    return pings.join(' ');
+  }
+
+  create_onMessageEventListener(handler: (message: DyNTS_DiB_Message, issuer: string) => void): void {
+    this.client.on('messageCreate', (message: Message) => {
+      handler(this.wrapMessage(message), 'discord');
+    });
+  }
+
+  create_onErrorEventListener(handler: (error: DyFM_AnyError) => void): void {
+    this.client.on('error', (error: Error) => {
+      handler(error);
+    });
+  }
+
+  async sendReport(message: string): Promise<DyNTS_DiB_Message> {
+    return await this.sendMessageToChannelByName(this.config.reportChannelName, message);
+  }
+
+  async sendReportIn(message: string): Promise<DyNTS_DiB_Message> {
+    return await this.sendMessageToChannelByName(
+      this.config.reportChannelName, 
+      `${this.botDisplayName} report for duty! ` +
+        `(v${DyNTS_global_settings.systemVersion} ${DyNTS_global_settings.env_settings?.environment})`
+    );
+  }
+
+  wrapMessage(message: Message): DyNTS_DiB_Message {
+    return {
+      id: message.id,
+      content: message.content,
+      authorId: message.author.id,
+      authorName: message.author.username,
+      authorDisplayName: message.author.displayName,
+      channelId: message.channel.id,
+      channelName: (message.channel as TextChannel)?.name || 'DM Channel with ' + (message.channel as DMChannel).recipient.username,
+      timestamp: message.createdTimestamp,
+      isBot: message.author.bot,
+      replyToMessageId: message.reference?.messageId,
+      mentions: Array.from(message.mentions.users.keys()),
+      rawPlatformMessage: message,
+      provider: this,
+    };
+  }
+
+  wrapChannel(channel: Channel): DyNTS_DiB_Channel {
+    return {
+      id: channel.id,
+      name: (channel as TextChannel).name || ('DM Channel with ' + (channel as DMChannel).recipient.username),
+      isTextBased: channel.isTextBased(),
+      isDM: channel.isDMBased(),
+      rawPlatformChannel: channel,
+
+      provider: this,
+    };
+  }
+
+  wrapUser(user: GuildMember): DyNTS_DiB_User {
+    return {
+      id: user.user.id,
+      username: user.user.username,
+      displayName: user.displayName,
+      isBot: user.user.bot,
+      rawPlatformUser: user,
+      
+      provider: this,
+    };
+  }
+}

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

@@ -5,11 +5,8 @@
 //
 
 // TYPES
-export * from './_models/dib-platform.types';
+/* export * from './_models/dib-platform.types'; */
 
 // SERVICES
-export * from './_services/dib-messaging-provider.service';
+export * from './_services/dib-messaging-provider.control-service';
 
-// COLLECTIONS
-export * from './_collections/dib-operations.util';
-export * from './_collections/dib.util';

package/src/_modules/bot/_modules/dynamo-bot/_collections/dyb-operations.util.ts

@@ -1,5 +1,5 @@
 import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
-import { DyNTS_DyB_MessagingProvider } from '../_services/dyb-messaging-provider.service';
+import { DyNTS_DyB_MessagingProvider_ControlService } from '../_services/dyb-messaging-provider.control-service';
 import { DyNTS_DyB_Message, DyNTS_DyB_Channel } from '../_models/dyb-platform.types';
 
 export class DyNTS_DyB_Operations_Util {
@@ -7,13 +7,16 @@ export class DyNTS_DyB_Operations_Util {
   /**
    * Get conversation statistics
    */
-  static async getConversationStats(provider: DyNTS_DyB_MessagingProvider, conversationId: string): Promise<{
+  static async getConversationStats(
+    provider: DyNTS_DyB_MessagingProvider_ControlService, 
+    conversationId: string
+  ): Promise<{
     messageCount: number;
     participantCount: number;
     lastActivity: Date | null;
   }> {
     try {
-      const messages: DyNTS_DyB_Message[] = await provider.fetchMessages(conversationId, 1000);
+      const messages: DyNTS_DyB_Message[] = await provider.fetchMessagesById(conversationId, 1000);
       const channel: DyNTS_DyB_Channel = await provider.getChannelById(conversationId);
       
       return {
@@ -35,12 +38,12 @@ export class DyNTS_DyB_Operations_Util {
    * Search messages in conversation
    */
   static async searchMessages(
-    provider: DyNTS_DyB_MessagingProvider, 
+    provider: DyNTS_DyB_MessagingProvider_ControlService, 
     conversationId: string, 
     searchTerm: string
   ): Promise<DyNTS_DyB_Message[]> {
     try {
-      const messages: DyNTS_DyB_Message[] = await provider.fetchMessages(conversationId, 1000);
+      const messages: DyNTS_DyB_Message[] = await provider.fetchMessagesById(conversationId, 1000);
       return messages.filter((msg: DyNTS_DyB_Message) => 
         msg.content.toLowerCase().includes(searchTerm.toLowerCase())
       );

package/src/_modules/bot/_modules/dynamo-bot/_models/dyb-platform.types.ts

@@ -1,15 +1,15 @@
-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_MessageWrapper } from '../../../_models/bot-message-wrapper.interface';
+import { DyNTS_Bot_ChannelWrapper } from '../../../_models/bot-channel-wrapper.interface';
+import { DyNTS_Bot_UserWrapper } from '../../../_models/bot-user-wrapper.interface';
 import { DyFM_Msg_Message, DyFM_Msg_Conversation, DyFM_Msg_Participant } from '@futdevpro/fsm-dynamo/messaging';
 
 // Dynamo Bot Platform-Specific Types
 // Uses messaging system models as the underlying platform
-export type DyNTS_DyB_Message = DyNTS_Bot_Message<DyFM_Msg_Message>;
+export type DyNTS_DyB_Message = DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>;
 
 // Extended channel interface for dynamo bot with participants
-export interface DyNTS_DyB_Channel extends DyNTS_Bot_Channel<DyFM_Msg_Conversation> {
+export interface DyNTS_DyB_Channel extends DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> {
   participants?: DyFM_Msg_Participant[];
 }
 
-export type DyNTS_DyB_User = DyNTS_Bot_User<any>; // Messaging system user (generic)
+export type DyNTS_DyB_User = DyNTS_Bot_UserWrapper<any>; // Messaging system user (generic)