@futdevpro/nts-dynamo 1.14.8 → 1.14.9

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

@@ -0,0 +1,100 @@
+import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyFM_AI_Message } from '@futdevpro/fsm-dynamo/ai';
+import { DyNTS_Bot_IO_ControlService } from '../../bot/_services/bot-io.control-service';
+import { DyNTS_Bot_Message } from '../../bot/_models/bot-message.interface';
+import { DyNTS_Bot_Channel } from '../../bot/_models/bot-channel.interface';
+import { DyNTS_Bot_User } from '../../bot/_models/bot-user.interface';
+import { DyNTS_Bot_Provider } from '../../bot/_models/bot-provider.interface';
+import { DyNTS_Ass_Main_ControlService } from './ass-main.control-service';
+import { DyNTS_Ass_Util } from '../_collections/ass.util';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_AI_LLMChat_ServiceBase } from '../../ai/_services/ai-llm-chat.service-base';
+
+/**
+ * Assistant IO Control Service
+ * Handles message processing with AI provider
+ * EXACT SAME LOGIC as DiAs_IO_ControlService but platform and AI provider agnostic
+ */
+export abstract class DyNTS_Ass_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_CommsProvider extends DyNTS_Bot_Provider<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser
+  > = DyNTS_Bot_Provider<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser
+  >
+> extends DyNTS_Bot_IO_ControlService<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_CommsProvider> {
+
+  protected abstract override getMainBotControlService(): DyNTS_Ass_Main_ControlService<
+    T_PlatformChannel,
+    T_PlatformMessage,
+    T_PlatformUser,
+    T_CommsProvider
+  >;
+  
+  protected abstract override mainBot_CS: DyNTS_Ass_Main_ControlService<
+    T_PlatformChannel,
+    T_PlatformMessage,
+    T_PlatformUser,
+    T_CommsProvider
+  >;
+  
+  get aiProvider(): DyNTS_AI_LLMChat_ServiceBase {
+    return this.mainBot_CS?.aiProvider;
+  }
+  
+  /**
+   * Handle incoming message with AI
+   * EXACT SAME LOGIC as dias-io.control-service.ts handleMessage()
+   */
+  override async handleMessage(message: T_PlatformMessage, issuer: string): Promise<T_PlatformMessage> {
+    try {
+      // Gather messages from comms platform
+      const messages: T_PlatformMessage[] = await this.mainBot_CS.gatherMessagesForMessage(message);
+      
+      // Convert to AI conversation format (uses EXISTING DyFM_AI_Message)
+      const aiMessages: DyFM_AI_Message[] = 
+        DyNTS_Ass_Util.convertBotMessagesToAIConversation({
+          messages: messages,
+          botClientId: this.mainBot_CS.botClientId,
+          botDisplayName: this.mainBot_CS.botDisplayName,
+          issuer: issuer,
+        });
+      
+      // Get AI response using EXISTING getAnswerInConversation method
+      const aiResult: string = await this.aiProvider.getAnswerInConversation({
+        conversation: aiMessages,
+        issuer: issuer,
+        settings: {
+          systemPrompt: this.mainBot_CS.defaultSystemPrompt,
+        },
+      });
+      
+      // Reply via comms platform
+      return await this.provider.replyToMessage(message.id, message.channelId, aiResult);
+    } catch (error) {
+      DyFM_Error.logSimple('❌❌ Error handleMessage:', error);
+      
+      if (!this.dontSendErrorReply && DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
+        await this.provider.replyToMessage(
+          message.id,
+          message.channelId,
+          `[SYSTEM|ERROR|${DyNTS_global_settings.systemShortCodeName}|DyNTS-Ass-IOCS-H0] Error occurred while handling the message:\n` +
+          DyFM_Error.getAnyMessage(error)
+        ).catch(error => {
+          DyFM_Error.logSimple('❌❌ Error sending error reply:', error);
+        });
+      }
+      
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('handleMessage', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Ass-IOCS-H0`,
+      });
+    }
+  }
+}

package/src/_modules/assistant/_services/ass-main.control-service.ts

@@ -0,0 +1,38 @@
+import { DyNTS_Ass_ServiceBase } from './ass.service-base';
+import { DyNTS_Ass_IO_ControlService } from './ass-io.control-service';
+import { DyNTS_Bot_Channel } from '../../bot/_models/bot-channel.interface';
+import { DyNTS_Bot_Message } from '../../bot/_models/bot-message.interface';
+import { DyNTS_Bot_User } from '../../bot/_models/bot-user.interface';
+import { DyNTS_Bot_Provider } from '../../bot/_models/bot-provider.interface';
+
+/**
+ * Assistant Main Control Service
+ * Abstract base for concrete assistant implementations
+ */
+export abstract class DyNTS_Ass_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_CommsProvider extends DyNTS_Bot_Provider<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser
+  > = DyNTS_Bot_Provider<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser
+  >
+> extends DyNTS_Ass_ServiceBase<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_CommsProvider> {
+  protected abstract override getBotIOControlService(): DyNTS_Ass_IO_ControlService<
+    T_PlatformChannel,
+    T_PlatformMessage,
+    T_PlatformUser,
+    T_CommsProvider
+  >;
+  protected abstract override botIO_CS: DyNTS_Ass_IO_ControlService<
+    T_PlatformChannel,
+    T_PlatformMessage,
+    T_PlatformUser,
+    T_CommsProvider
+  >;
+}

package/src/_modules/assistant/_services/ass.service-base.ts

@@ -0,0 +1,92 @@
+import { DyNTS_Bot_Main_ControlService } from '../../bot/_services/bot-main.control-service';
+import { DyNTS_Bot_Message } from '../../bot/_models/bot-message.interface';
+import { DyNTS_Bot_Channel } from '../../bot/_models/bot-channel.interface';
+import { DyNTS_Bot_User } from '../../bot/_models/bot-user.interface';
+import { DyNTS_Bot_Provider } from '../../bot/_models/bot-provider.interface';
+import { DyNTS_AI_LLMChat_ServiceBase } from '../../ai/_services/ai-llm-chat.service-base';
+import { DyFM_AI_Message } from '@futdevpro/fsm-dynamo/ai';
+import { DyNTS_Ass_global_settings } from '../_collections/ass-global-settings.const';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_Ass_Util } from '../_collections/ass.util';
+import { DyNTS_Ass_IO_ControlService } from './ass-io.control-service';
+
+/**
+ * Assistant Service Base
+ * Integrates commsProvider (bot) and aiProvider (LLMChat) to create AI-powered assistant
+ * USES EXISTING AI ABSTRACTIONS - no duplication
+ */
+export abstract class DyNTS_Ass_ServiceBase<
+  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_CommsProvider extends DyNTS_Bot_Provider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser> = DyNTS_Bot_Provider<T_PlatformChannel, T_PlatformMessage, T_PlatformUser>
+> extends DyNTS_Bot_Main_ControlService<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_CommsProvider> {
+
+  // AI Provider - uses EXISTING abstraction
+  protected _aiProvider: DyNTS_AI_LLMChat_ServiceBase;
+  
+  get aiProvider(): DyNTS_AI_LLMChat_ServiceBase {
+    return this._aiProvider;
+  }
+  
+  protected abstract getAIProvider(): DyNTS_AI_LLMChat_ServiceBase;
+  
+  // Override botIO to use assistant IO
+  protected abstract override getBotIOControlService(): DyNTS_Ass_IO_ControlService<
+    T_PlatformChannel,
+    T_PlatformMessage,
+    T_PlatformUser,
+    T_CommsProvider
+  >;
+  
+  // Assistant-specific settings
+  defaultSystemPrompt: string = DyNTS_Ass_global_settings.defaultSystemPrompt;
+  
+  protected constructor(setupAutomatically?: boolean) {
+    super(setupAutomatically);
+    
+    // Initialize AI provider
+    this._aiProvider = this.getAIProvider();
+    
+    // Apply system prompt
+    if (this._aiProvider.defaultSettings) {
+      this._aiProvider.defaultSettings.systemPrompt = this.defaultSystemPrompt;
+    }
+    
+    // Set global settings
+    DyNTS_global_settings.assistant_settings ??= DyNTS_Ass_global_settings;
+  }
+  
+  /**
+   * Gather messages from comms platform (any platform)
+   * Same as dias.service-base but platform-agnostic
+   */
+  async gatherMessagesForMessage(message: T_PlatformMessage, limit: number = 100): Promise<T_PlatformMessage[]> {
+    const channelId = message.channelId;
+    const messages = await this.provider.fetchMessages(channelId, limit);
+    
+    // Filter out messages with skip flags
+    return messages.filter(
+      msg => !DyNTS_Ass_global_settings.skipConversationMessagesFlags.some(
+        flag => msg.content.includes(flag)
+      )
+    ).sort((a, b) => a.timestamp - b.timestamp);
+  }
+  
+  /**
+   * Convert gathered messages to AI conversation using EXISTING DyFM_AI_Message
+   */
+  async gatherMessagesAsAIConversation(
+    message: T_PlatformMessage,
+    issuer: string,
+  ): Promise<DyFM_AI_Message[]> {
+    const messages = await this.gatherMessagesForMessage(message);
+    
+    return DyNTS_Ass_Util.convertBotMessagesToAIConversation({
+      messages: messages,
+      botClientId: this.botClientId,
+      botDisplayName: this.botDisplayName,
+      issuer: issuer,
+    });
+  }
+}

package/src/_modules/assistant/index.ts

@@ -0,0 +1,19 @@
+//
+// Assistant module (platform and AI provider agnostic)
+//
+// Integrates commsProvider (bot) with aiProvider (AI LLMChat) to create intelligent assistants
+// REUSES existing AI abstractions - no duplication
+//
+
+// MODELS
+export * from './_models/ass-global-settings.interface';
+
+// COLLECTIONS
+export * from './_collections/ass.util';
+export * from './_collections/ass-global-settings.const';
+
+// SERVICES
+export * from './_services/ass.service-base';
+export * from './_services/ass-main.control-service';
+export * from './_services/ass-io.control-service';
+

package/src/_modules/bot/_collections/bot-default-commands.const.ts

@@ -0,0 +1,12 @@
+import { DyNTS_Bot_Command } from '../_models/bot-command.interface';
+
+export const DyNTS_Bot_defaultCommands: DyNTS_Bot_Command[] = [
+  {
+    command: '!ping',
+    description: 'Ping the bot',
+    commandHandler: async (message) => {
+      // This will be handled by the provider's replyToMessage method
+      // The actual implementation will be in the provider
+    },
+  },
+]

package/src/_modules/bot/_collections/bot-global-settings.const.ts

@@ -0,0 +1,39 @@
+import { DyNTS_Bot_Global_Settings } from '../_models/bot-global-settings.interface';
+import { minute, week } from '@futdevpro/fsm-dynamo';
+import { DyNTS_Bot_defaultCommands } from './bot-default-commands.const';
+
+export const DyNTS_Bot_global_settings: DyNTS_Bot_Global_Settings = {
+  debugLevel: 3,
+
+  allowedUsers: 'all',
+
+  messageSettings: {
+    messageFetchTimeLimit: 3 * week,
+    messageFetchCountLimit: 1000,
+    messageSendDelay: minute / 3,
+
+    skipFlags: [
+      '[BOT-SKIP]',
+      '[SYSTEM|REFUSE|BOT]',
+    ],
+  },
+
+  channelSettings: {
+    reportChannelName: 'bot-reports',
+
+    defaultChannels: [
+      'bot-help',
+    ],
+
+    allowedChannels: [],
+    dmIsAllowed: false,
+  },
+
+  commandSettings: {
+    commandOperator: '',
+
+    commands: DyNTS_Bot_defaultCommands,
+  },
+
+  allowBotsInteractEachOther: false,
+};

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

@@ -0,0 +1,149 @@
+import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_Bot_Provider } from '../_models/bot-provider.interface';
+import { DyNTS_Bot_Message } from '../_models/bot-message.interface';
+import { DyNTS_Bot_Channel } from '../_models/bot-channel.interface';
+import { DyNTS_Bot_User } from '../_models/bot-user.interface';
+import { DyNTS_Bot_LastMessageDate } from '../_models/bot-last-message-date.interface';
+import { DyNTS_Bot_LastMentionDate } from '../_models/bot-last-mention-date.interface';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+
+export abstract class DyNTS_Bot_Operations_Util<
+  T_PlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
+  T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
+  T_PlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>,
+  T_PlatformProvider extends DyNTS_Bot_Provider<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser
+  > = DyNTS_Bot_Provider<
+    T_PlatformChannel, 
+    T_PlatformMessage, 
+    T_PlatformUser
+  >
+> {
+
+  static async findChannelByName<
+    T_PlatformChannel extends DyNTS_Bot_Channel<any>, 
+    T_PlatformProvider extends DyNTS_Bot_Provider<T_PlatformChannel, any, any>
+  >(
+    provider: T_PlatformProvider, 
+    name: string
+  ): Promise<T_PlatformChannel> {
+    const channel = await provider.getChannelByName(name);
+
+    if (!channel) {
+      DyFM_Log.error(`No text channel found with name "${name}"`)
+      return null;
+    }
+
+    return channel;
+  }
+
+  static async sendMessageToChannelByName<T_PlatformChannel extends DyNTS_Bot_Channel<any>, T_PlatformProvider extends DyNTS_Bot_Provider<T_PlatformChannel, any, any>>(
+    provider: T_PlatformProvider, 
+    channelName: string, 
+    message: string
+  ): Promise<void> {
+    const channel = await this.findChannelByName(provider, channelName);
+
+    if (channel?.isTextBased) {
+      await provider.sendMessageToChannelByName(channelName, message);
+      DyFM_Log.success('Message sent to channel', channel.name);
+    } else {
+      DyFM_Log.error(`Channel is not text based "${channelName}"`);
+    }
+  }
+
+  static async readMembersInChannel<T_PlatformUser extends DyNTS_Bot_User<any>, T_PlatformProvider extends DyNTS_Bot_Provider<any, any, T_PlatformUser>>(
+    provider: T_PlatformProvider, 
+    channelName: string
+  ): Promise<T_PlatformUser[]> {
+    return await provider.readMembersInChannel(channelName);
+  }
+
+  static async readMemberNamesInChannel<T_PlatformProvider extends DyNTS_Bot_Provider<any, any, any>>(
+    provider: T_PlatformProvider, 
+    channelName: string
+  ): Promise<string[]> {
+    return await provider.readMemberNamesInChannel(channelName);
+  }
+
+  static async fetchAllMessagesWithPaging<T_PlatformMessage extends DyNTS_Bot_Message<any>, T_PlatformProvider extends DyNTS_Bot_Provider<any, T_PlatformMessage, any>>(
+    provider: T_PlatformProvider,
+    channelId: string,
+    maxFetch = 1000
+  ): Promise<T_PlatformMessage[]> {
+    return await provider.fetchAllMessagesWithPaging(channelId, maxFetch);
+  }
+
+  static async readLastMessageDatesByMembers<T_PlatformProvider extends DyNTS_Bot_Provider<any, any, any>>(
+    provider: T_PlatformProvider, 
+    channelName: string,
+    memberNames: string[]
+  ): Promise<DyNTS_Bot_LastMessageDate[]> {
+    return await provider.readLastMessageDatesByMembers(channelName, memberNames);
+  }
+
+  static async readLastMessageWithMemberNamePingInIt<T_PlatformUser extends DyNTS_Bot_User<any>, T_PlatformProvider extends DyNTS_Bot_Provider<any, any, T_PlatformUser>>(
+    provider: T_PlatformProvider,
+    channelName: string,
+    users: T_PlatformUser[]
+  ): Promise<DyNTS_Bot_LastMentionDate[]> {
+    return await provider.readLastMessageWithMemberNamePingInIt(channelName, users);
+  }
+
+  static readMentionsInChannel = this.readLastMessageWithMemberNamePingInIt;
+
+  static async readLastMessagesInChannel<T_PlatformMessage extends DyNTS_Bot_Message<any>, T_PlatformChannel extends DyNTS_Bot_Channel<any>, T_PlatformProvider extends DyNTS_Bot_Provider<T_PlatformChannel, T_PlatformMessage, any>>(
+    provider: T_PlatformProvider,
+    channelName: string,
+  ): Promise<T_PlatformMessage[]> {
+    const channel = await provider.getChannelByName(channelName);
+    return await provider.fetchMessages(channel.id, 100);
+  }
+  
+  static async getLastMessageInChannel<T_PlatformMessage extends DyNTS_Bot_Message<any>, T_PlatformProvider extends DyNTS_Bot_Provider<any, T_PlatformMessage, any>>(
+    provider: T_PlatformProvider,
+    channelName: string
+  ): Promise<T_PlatformMessage> {
+    return await provider.getLastMessageInChannel(channelName);
+  }
+
+  static async deleteMessage<T_PlatformProvider extends DyNTS_Bot_Provider<any, any, any>>(
+    provider: T_PlatformProvider, 
+    messageId: string, 
+    channelId: string
+  ): Promise<void> {
+    await provider.deleteMessage(messageId, channelId).catch((error) => {
+      DyFM_Error.logSimple('Failed to delete message', error);
+    });
+
+    DyFM_Log.success('Message deleted');
+  }
+
+  static async reportIn<T_PlatformMessage extends DyNTS_Bot_Message<any>, T_PlatformProvider extends DyNTS_Bot_Provider<any, T_PlatformMessage, any>>(provider: T_PlatformProvider): Promise<void> {
+    try {
+      const lastReportMessage = await this.getLastMessageInChannel(
+        provider,
+        'bot-reports' // Use default since we can't access channelSettings from provider config
+      );
+      
+      const reportMessage = `${provider.getBotDisplayName()} report for duty! ` +
+        `(v${DyNTS_global_settings.systemVersion} ${DyNTS_global_settings.env_settings?.environment})`;
+
+      if (lastReportMessage?.content === reportMessage) {
+        await this.deleteMessage(provider, lastReportMessage.id, lastReportMessage.channelId).catch((error) => {
+          DyFM_Error.logSimple('Failed to delete message', error);
+        });
+      }
+
+      this.sendMessageToChannelByName(
+        provider, 
+        'bot-reports', // Use default since we can't access channelSettings from provider config
+        reportMessage
+      );
+    } catch (error) {
+      DyFM_Error.logSimple('Failed to report in', error);
+    }
+  }
+}

package/src/_modules/bot/_enums/bot-provider.enum.ts

@@ -0,0 +1,6 @@
+export enum DyNTS_Bot_Provider_Type {
+  discord = 'discord',
+  slack = 'slack',
+  teams = 'teams',
+  custom = 'custom'
+}

package/src/_modules/bot/_models/bot-channel.interface.ts

@@ -0,0 +1,7 @@
+export interface DyNTS_Bot_Channel<T_PlatformChannel = any> {
+  id: string;
+  name: string;
+  isTextBased: boolean;
+  isDM: boolean;
+  rawPlatformChannel: T_PlatformChannel;
+}

package/src/_modules/bot/_models/bot-command.interface.ts

@@ -0,0 +1,8 @@
+import { DyNTS_Bot_Message } from './bot-message.interface';
+
+export interface DyNTS_Bot_Command<T_PlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>> {
+  command: string;
+  description: string;
+  commandHandler: (message: T_PlatformMessage) => Promise<void>;
+  permissionNeeded?: (message: T_PlatformMessage) => Promise<boolean>;
+}

package/src/_modules/bot/_models/bot-global-settings.interface.ts

@@ -0,0 +1,87 @@
+import { DyNTS_Bot_Command } from './bot-command.interface';
+
+export interface DyNTS_Bot_Global_Settings {
+  /**
+   * this setting will set the debug level for the bot
+   * 
+   * 0 - no logs  
+   * 1 - errors sending to report channel  
+   * 2 - errors sending as response, will log events in console   
+   * 3 - errors sending as response, creating reports to report channel, debug events are in console (default)  
+   * 4 - errors and debug events are sending as response  
+   * 5 - all events are sending as response (that are set to send)  
+   * 6 - all debug logs are enabled  
+   *   
+   *   _
+   */
+  debugLevel: number;
+
+  allowedUsers: 'all' | string[];
+
+  messageSettings: {
+    /**
+     * this setting will set the time limit for message fetching
+     * so we will stop fetching messages sent later than this time
+     */
+    messageFetchTimeLimit: number;
+    /**
+     * this setting will set the count limit for message fetching
+     * so we will stop fetching messages after this count
+     */
+    messageFetchCountLimit: number;
+    /**
+     * this setting will set the delay for message sending,
+     * so we won't flood the channel too fast
+     */
+    messageSendDelay: number;
+
+    /**
+     * this setting will be used to skip answering to messages
+     * if the message contains any of these flags, the bot will not answer
+     * 
+     * @default [ '[BOT-SKIP]' ]
+     */
+    skipFlags: string[];
+  };
+
+  /**
+   * this setting will set the channel settings for the bot
+   */
+  channelSettings: {
+    /**
+     * this setting will set the name of the channel where the bot will send the reports
+     * 
+     * @default 'bot-report'
+     */
+    reportChannelName: string;
+
+    /**
+     * this setting will set the channels where the bot will answer automatically
+     * whenever a message is sent in one of these channels, that is not from the bot
+     * 
+     * it will be populated automatically from the default channels
+     */
+    allowedChannels: string[];
+    /**
+     * this setting will set if the bot can answer in Direct Messages Channels
+     * 
+     * @default false
+     */
+    dmIsAllowed: boolean;
+
+    /**
+     * this setting will set the default channels where the bot will answer automatically
+     * whenever a message is sent in one of these channels, that is not from the bot
+     * 
+     * @default [ 'bot-report' ]
+     */
+    defaultChannels: string[];
+  };
+
+  commandSettings: {
+    commandOperator: string;
+    commands: DyNTS_Bot_Command[];
+  };
+
+  allowBotsInteractEachOther: boolean;
+}

package/src/_modules/bot/_models/bot-last-mention-date.interface.ts

@@ -0,0 +1,6 @@
+export interface DyNTS_Bot_LastMentionDate {
+  memberId: string;
+  memberName: string;
+  allMentions: number;
+  lastMentionDate: Date | null;
+}

package/src/_modules/bot/_models/bot-last-message-date.interface.ts

@@ -0,0 +1,5 @@
+export interface DyNTS_Bot_LastMessageDate {
+  memberName: string;
+  allMessages: number;
+  lastMessageDate: Date | null;
+}

package/src/_modules/bot/_models/bot-message.interface.ts

@@ -0,0 +1,14 @@
+export interface DyNTS_Bot_Message<T_PlatformMessage = any> {
+  id: string;
+  content: string;
+  authorId: string;
+  authorName: string;
+  authorDisplayName: string;
+  channelId: string;
+  channelName: string;
+  timestamp: number;
+  isBot: boolean;
+  replyToMessageId?: string;
+  mentions: string[]; // user IDs
+  rawPlatformMessage: T_PlatformMessage; // Original platform message for platform-specific operations
+}

package/src/_modules/bot/_models/bot-provider.interface.ts

@@ -0,0 +1,80 @@
+import { DyNTS_Bot_Message } from './bot-message.interface';
+import { DyNTS_Bot_Channel } from './bot-channel.interface';
+import { DyNTS_Bot_User } from './bot-user.interface';
+import { DyNTS_Bot_LastMessageDate } from './bot-last-message-date.interface';
+import { DyNTS_Bot_LastMentionDate } from './bot-last-mention-date.interface';
+import { DyNTS_Bot_Provider_Type } from '../_enums/bot-provider.enum';
+import { DyNTS_Bot_Global_Settings } from './bot-global-settings.interface';
+
+export interface DyNTS_Bot_Provider_Config extends DyNTS_Bot_Global_Settings {
+  provider: DyNTS_Bot_Provider_Type;
+  providerInstance?: DyNTS_Bot_Provider;
+  discord?: {
+    token: string;
+    guildId: string;
+    clientId: string;
+    oauth2Url: string;
+  };
+  slack?: {
+    token: string;
+    workspace: string;
+  };
+  teams?: {
+    appId: string;
+    appPassword: string;
+    tenantId: string;
+  };
+}
+
+export interface DyNTS_Bot_Provider<
+  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>
+> {
+  // Initialization
+  initialize(config: DyNTS_Bot_Provider_Config): Promise<void>;
+  login(token: string): Promise<void>;
+  
+  // Channel operations
+  getChannelByName(name: string): Promise<T_PlatformChannel>;
+  sendMessageToChannelByName(channelName: string, message: string): Promise<T_PlatformMessage>;
+  getMessagesFromChannelByChannelName(channelName: string, limit?: number): Promise<T_PlatformMessage[]>;
+  getLastMessageInChannel(channelName: string): Promise<T_PlatformMessage>;
+  clearChannel(channelId: string): Promise<void>;
+  
+  // Message operations
+  sendMessage(channelId: string, content: string): Promise<T_PlatformMessage>;
+  replyToMessage(messageId: string, channelId: string, content: string): Promise<T_PlatformMessage>;
+  sendTyping(channelId: string): Promise<void>;
+  fetchMessages(channelId: string, limit: number): Promise<T_PlatformMessage[]>;
+  fetchAllMessagesWithPaging(channelId: string, maxFetch?: number): Promise<T_PlatformMessage[]>;
+  deleteMessage(messageId: string, channelId: string): Promise<void>;
+  
+  // User operations
+  getUserByName(username: string): Promise<T_PlatformUser>;
+  getUserMention(userId: string): string;
+  readMembersInChannel(channelName: string): Promise<T_PlatformUser[]>;
+  readMemberNamesInChannel(channelName: string): Promise<string[]>;
+  
+  // Advanced message queries
+  getLastMessageSentBy(channelName: string, username: string): Promise<T_PlatformMessage>;
+  getLastMentionOf(channelName: string, username: string): Promise<T_PlatformMessage>;
+  readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<DyNTS_Bot_LastMessageDate[]>;
+  readLastMessageWithMemberNamePingInIt(channelName: string, users: T_PlatformUser[]): Promise<DyNTS_Bot_LastMentionDate[]>;
+  
+  // Platform-specific features (optional, may return null/undefined for unsupported platforms)
+  getRoleByName?(roleName: string): any;
+  getRolePingByName?(roleName: string): Promise<string>;
+  getRolePingsByName?(roleNames: string[]): Promise<string>;
+  
+  // Event binding
+  onMessage(handler: (message: T_PlatformMessage, issuer: string) => void): void;
+  onReady(handler: () => void): void;
+  onError(handler: (error: Error) => void): void;
+  
+  // Metadata
+  getBotId(): string;
+  getBotDisplayName(): string;
+  getProviderName(): string;
+  isReady(): boolean;
+}