@futdevpro/nts-dynamo 1.14.28 → 1.14.31

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

@@ -1,38 +1,89 @@
-import { DyNTS_Ass_ServiceBase } from './ass.service-base';
+import { DyNTS_Bot_Main_ControlService } from '../../bot/_services/bot-main.control-service';
+import { DyNTS_Bot_MessageWrapper } from '../../bot/_models/bot-message-wrapper.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';
-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_MessagingProvider } from '../../bot/_models/bot-messaging-provider.interface';
+import { DyNTS_Bot_MessagingProvider_Type } from '../../bot/_enums/bot-message-provider.enum';
 
 /**
- * Assistant Main Control Service
- * Abstract base for concrete assistant implementations
+ * 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_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_MessagingProvider<
-    T_PlatformChannel, 
-    T_PlatformMessage, 
-    T_PlatformUser
-  > = DyNTS_Bot_MessagingProvider<
-    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
-  >;
+  T_MessagingPlatformProvider_Type extends DyNTS_Bot_MessagingProvider_Type | string = DyNTS_Bot_MessagingProvider_Type,
+> extends DyNTS_Bot_Main_ControlService<T_MessagingPlatformProvider_Type> {
+
+  // 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; */
+  
+  protected abstract override getBotIOControlService(): DyNTS_Ass_IO_ControlService;
+  declare botIO_CS: DyNTS_Ass_IO_ControlService;
+  
+  // Assistant-specific settings
+  defaultSystemPrompt: string = DyNTS_Ass_global_settings.defaultSystemPrompt;
+  
+  protected constructor() {
+    super();
+    
+    // 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
+   * Now uses wrapper's provider to ensure messages from correct platform
+   */
+  async gatherMessagesForMessage(
+    message: DyNTS_Bot_MessageWrapper<any>,
+    limit: number = 100
+  ): Promise<DyNTS_Bot_MessageWrapper<any>[]> {
+    // Use wrapper's provider to fetch messages from the correct platform
+    const messages: DyNTS_Bot_MessageWrapper<any>[] = await message.provider.fetchMessagesForMessage(message, 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: DyNTS_Bot_MessageWrapper<any>,
+    issuer: string,
+  ): Promise<DyFM_AI_Message[]> {
+    const messages: DyNTS_Bot_MessageWrapper<any>[] = await this.gatherMessagesForMessage(message);
+    
+    return DyNTS_Ass_Util.convertBotMessagesToAIConversation({
+      messages: messages,
+      botClientId: message.provider.botId,
+      botDisplayName: message.provider.botDisplayName,
+      issuer: issuer,
+    });
+  }
 }

package/src/_modules/assistant/index.ts

@@ -13,7 +13,7 @@ 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-main.control-service';
 export * from './_services/ass-io.control-service';
 

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

@@ -0,0 +1,24 @@
+import { DyNTS_Bot_MessagingProvider_ServiceBase } from '../_services/bot-messaging-provider.service-base';
+
+/**
+ * Wraps a bot channel with provider context
+ * This ensures channels include the provider information needed for platform-specific operations
+ */
+export interface DyNTS_Bot_ChannelWrapper<
+  T_MessagingPlatformChannel extends any = any
+> {
+  id: string;
+  name: string;
+  isTextBased: boolean;
+  isDM: boolean;
+  rawPlatformChannel: T_MessagingPlatformChannel;
+  
+  /** Reference to the provider instance for platform-specific operations */
+  provider: DyNTS_Bot_MessagingProvider_ServiceBase<
+    T_MessagingPlatformChannel, 
+    any, //DyNTS_Bot_MessageWrapper<any>, 
+    any, //DyNTS_Bot_UserWrapper<any>, 
+    any
+  >;
+}
+

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

@@ -1,6 +1,6 @@
-import { DyNTS_Bot_Message } from './bot-message.interface';
+import { DyNTS_Bot_MessageWrapper } from './bot-message-wrapper.interface';
 
-export interface DyNTS_Bot_Command<T_MessagingPlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>> {
+export interface DyNTS_Bot_Command<T_MessagingPlatformMessage extends DyNTS_Bot_MessageWrapper<any> = DyNTS_Bot_MessageWrapper<any>> {
   command: string;
   description: string;
   commandHandler: (message: T_MessagingPlatformMessage) => Promise<void>;

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

@@ -1,5 +1,5 @@
 import { DyNTS_Bot_Command } from './bot-command.interface';
-import { DyNTS_Bot_MessagingProvider_Config } from './bot-messaging-provider.interface';
+import { DyNTS_Bot_MessagingProvider_Config } from '../_services/bot-messaging-provider.service-base';
 
 export interface DyNTS_Bot_Global_Settings {
   /**

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

@@ -1,8 +1,4 @@
-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_MessagingProvider } from './bot-messaging-provider.interface';
-import { DyNTS_Bot_MessagingProvider_Type } from '../_enums/bot-message-provider.enum';
+import { DyNTS_Bot_MessagingProvider_ServiceBase } from '../_services/bot-messaging-provider.service-base';
 
 /**
  * Wraps a bot message with provider context
@@ -10,23 +6,27 @@ import { DyNTS_Bot_MessagingProvider_Type } from '../_enums/bot-message-provider
  * back through the correct platform
  */
 export interface DyNTS_Bot_MessageWrapper<
-  T_MessagingPlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
-  
+  T_MessagingPlatformMessage extends any = any,
 > {
-  /** The wrapped message */
-  message: T_MessagingPlatformMessage;
-  
-  /** Unique identifier for the provider instance */
-  providerId: string;
-  
-  /** Type of the provider (discord, slack, teams, dynamo) */
-  providerType: DyNTS_Bot_MessagingProvider_Type;
+  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_MessagingPlatformMessage; // Original platform message for platform-specific operations
   
   /** Reference to the provider instance for sending replies */
-  provider: DyNTS_Bot_MessagingProvider<
-    DyNTS_Bot_Channel<any>,
+  provider: DyNTS_Bot_MessagingProvider_ServiceBase<
+    any,
     T_MessagingPlatformMessage,
-    DyNTS_Bot_User<any>
+    any, //DyNTS_Bot_ChannelWrapper<any>,
+    any //DyNTS_Bot_UserWrapper<any>
   >;
 }
 

package/src/_modules/bot/_models/bot-user-wrapper.interface.ts

@@ -0,0 +1,35 @@
+import { DyNTS_Bot_MessagingProvider_ServiceBase } from '../_services/bot-messaging-provider.service-base';
+
+/**
+ * Wraps a bot user with provider context
+ * This ensures users include the provider information needed for platform-specific operations
+ */
+export interface DyNTS_Bot_UserWrapper<
+  T_MessagingPlatformUser extends any = any,
+  /* T_MessagingPlatformService extends DyNTS_Bot_MessagingProvider_ServiceBase<
+    any, //DyNTS_Bot_ChannelWrapper<any> , 
+    any, //DyNTS_Bot_MessageWrapper<any> , 
+    T_MessagingPlatformUser,
+    any
+  > = DyNTS_Bot_MessagingProvider_ServiceBase<
+    any, //DyNTS_Bot_ChannelWrapper<any> , 
+    any, //DyNTS_Bot_MessageWrapper<any> , 
+    T_MessagingPlatformUser,
+    any
+  > */
+    
+> {
+  id: string;
+  username: string;
+  displayName: string;
+  isBot: boolean;
+  rawPlatformUser: T_MessagingPlatformUser;
+  
+  /** Reference to the provider instance for platform-specific operations */
+  provider:/*  T_MessagingPlatformService; */ DyNTS_Bot_MessagingProvider_ServiceBase<
+    any, //DyNTS_Bot_ChannelWrapper<any> , 
+    any, //DyNTS_Bot_MessageWrapper<any> , 
+    T_MessagingPlatformUser
+  >;
+}
+

package/src/_modules/bot/_modules/discord-bot/_models/dib-platform.types.ts

@@ -1,9 +1,10 @@
-import { Message, TextChannel, GuildMember } from 'discord.js';
-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 { Message, TextChannel, GuildMember, Channel } from 'discord.js';
+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';
 
 // Discord Bot Platform-Specific Types
-export type DyNTS_DiB_Message = DyNTS_Bot_Message<Message>;
-export type DyNTS_DiB_Channel = DyNTS_Bot_Channel<TextChannel>;
-export type DyNTS_DiB_User = DyNTS_Bot_User<GuildMember>;
+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>;
+ */