@futdevpro/nts-dynamo 1.14.7 → 1.14.9

package/src/_modules/ai/_modules/open-ai/_services/oai-doc-page.data-service.ts

@@ -106,12 +106,6 @@ export class DyNTS_OAI_DocPageDataService<
 
   async processPage(page: T_Page): Promise<DyNTS_DAI_DocPageCompareResult<T_Chunk, T_Page>> {
     try {
-      // ugyan a logikus az lenne, ha először compare-elnénk, és csak az után mentenénk, 
-      //   de akkor nem lenne id, amit a sub-element-ekhez kellenek, ezért...
-      // - először kikérjük a régi adatot, 
-      // - aztán mentünk, hogy legyen id, 
-      // - és utána compare-eljük
-
       let existingPage: T_Page;
       if (page._id) {
         existingPage = await this.findData({
@@ -131,30 +125,47 @@ export class DyNTS_OAI_DocPageDataService<
         } as DyFM_DBFilterSimple<T_Page>);
       }
 
-      // save the page to ensure its id (create new obj, to protect from chunks deletion)
-      let pageDataToSave: T_Page;
+      let pageCompareResult: DyNTS_DAI_DocPageCompareResult<T_Chunk, T_Page>;
+      
       if (existingPage) {
-        pageDataToSave = existingPage;
-        Object.assign(pageDataToSave, page);
+        // Compare first to determine if we need to save
+        pageCompareResult = await this.comparePage(page, existingPage);
+        
+        if (pageCompareResult.result === DyNTS_DAI_CompareResult_Type.equal) {
+          // No changes detected, reuse existing page without saving
+          pageCompareResult.newPage = existingPage;
+          pageCompareResult.oldPage = existingPage;
+        } else {
+          // Changes detected, save the updated page
+          let pageDataToSave: T_Page;
+          pageDataToSave = existingPage;
+          Object.assign(pageDataToSave, page);
+          delete pageDataToSave.chunks;
+
+          const savedPage: T_Page = await this.saveData(pageDataToSave, true);
+
+          page.chunks.forEach((chunk: T_Chunk) => {
+            chunk.documentId = savedPage.documentId;
+            chunk.pageId = savedPage._id;
+          });
+          page._id = savedPage._id;
+          pageCompareResult.newPage = page;
+        }
       } else {
-        pageDataToSave = {
+        // New page, save it first to get ID
+        const pageDataToSave: T_Page = {
           ...page,
         };
-      }
-      delete pageDataToSave.chunks;
+        delete pageDataToSave.chunks;
 
-      const savedPage: T_Page = await this.saveData(pageDataToSave, true);
+        const savedPage: T_Page = await this.saveData(pageDataToSave, true);
 
-      page.chunks.forEach((chunk: T_Chunk) => {
-        chunk.documentId = savedPage.documentId;
-        chunk.pageId = savedPage._id;
-      });
-      page._id = savedPage._id;
+        page.chunks.forEach((chunk: T_Chunk) => {
+          chunk.documentId = savedPage.documentId;
+          chunk.pageId = savedPage._id;
+        });
+        page._id = savedPage._id;
 
-      let pageCompareResult: DyNTS_DAI_DocPageCompareResult<T_Chunk, T_Page>;
-      if (existingPage) {
-        pageCompareResult = await this.comparePage(page, existingPage);
-      } else {
         pageCompareResult = {
           result: DyNTS_DAI_CompareResult_Type.new,
           newPage: page,
@@ -263,6 +274,7 @@ export class DyNTS_OAI_DocPageDataService<
       const messages: string[] = [];
       const chunkCompareResults: DyNTS_DAI_DocChunkCompareResult<T_Chunk>[] = [];
 
+      // Compare all relevant fields for comprehensive change detection
       if (newPage.name !== oldPage.name) {
         pageCompareResult = DyNTS_DAI_CompareResult_Type.modified;
         messages.push(`Page name modified`);
@@ -271,7 +283,42 @@ export class DyNTS_OAI_DocPageDataService<
       if (newPage.content !== oldPage.content) {
         pageCompareResult = DyNTS_DAI_CompareResult_Type.modified;
         messages.push(`Page content modified`);
+      }
 
+      // Compare allFlaggedParents arrays
+      const allFlaggedParentsEqual = this.compareStringArrays(
+        newPage.allFlaggedParents || [], 
+        oldPage.allFlaggedParents || []
+      );
+      if (!allFlaggedParentsEqual) {
+        pageCompareResult = DyNTS_DAI_CompareResult_Type.modified;
+        messages.push(`Page allFlaggedParents modified`);
+      }
+
+      // Compare allFlaggedParentsMerged
+      if (newPage.allFlaggedParentsMerged !== oldPage.allFlaggedParentsMerged) {
+        pageCompareResult = DyNTS_DAI_CompareResult_Type.modified;
+        messages.push(`Page allFlaggedParentsMerged modified`);
+      }
+
+      // Compare filePath
+      if (newPage.filePath !== oldPage.filePath) {
+        pageCompareResult = DyNTS_DAI_CompareResult_Type.modified;
+        messages.push(`Page filePath modified`);
+      }
+
+      // Compare parentedPath arrays
+      const parentedPathEqual = this.compareStringArrays(
+        newPage.parentedPath || [], 
+        oldPage.parentedPath || []
+      );
+      if (!parentedPathEqual) {
+        pageCompareResult = DyNTS_DAI_CompareResult_Type.modified;
+        messages.push(`Page parentedPath modified`);
+      }
+
+      // Only process chunks if page content actually changed
+      if (pageCompareResult === DyNTS_DAI_CompareResult_Type.modified) {
         const docChunk_DS: DyNTS_OAI_DocChunkDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document> = 
           this.getDocChunkDataService();
 
@@ -300,6 +347,13 @@ export class DyNTS_OAI_DocPageDataService<
     }
   }
 
+  private compareStringArrays(arr1: string[], arr2: string[]): boolean {
+    if (arr1.length !== arr2.length) {
+      return false;
+    }
+    return arr1.every((item, index) => item === arr2[index]);
+  }
+
   /* async comparePage_deep(page: T_Page, oldPage: T_Page): Promise<DyNTS_DAI_DocPageCompareResult<T_Chunk, T_Page>> {
     try {
       if (this.debugLog) {

package/src/_modules/ai/_modules/open-ai/_services/oai-document.data-service.ts

@@ -128,13 +128,6 @@ export class DyNTS_OAI_DocumentDataService<
     DyNTS_DAI_DocumentCompareResult<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata, T_Document>
   > {
     try {
-      // ugyan a logikus az lenne, ha először compare-elnénk, és csak az után mentenénk, 
-      //   de akkor nem lenne id, amit a sub-element-ekhez kellenek, ezért...
-      // - először kikérjük a régi adatot, 
-      // - aztán mentünk, hogy legyen id, 
-      // - és utána compare-eljük
-
-
       let existingDocument: T_Document; 
 
       if (document._id) {
@@ -154,30 +147,47 @@ export class DyNTS_OAI_DocumentDataService<
         });
       }
 
-      // save the document to ensure its id (create new obj, to protect from pages deletion)
-      let docDataToSave: T_Document;
+      let documentCompareResult: DyNTS_DAI_DocumentCompareResult<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata, T_Document>;
+      
       if (existingDocument) {
-        docDataToSave = existingDocument;
-        Object.assign(docDataToSave, document);
+        // Compare first to determine if we need to save
+        documentCompareResult = await this.compareDocument_deep(document, existingDocument);
+        
+        if (documentCompareResult.result === DyNTS_DAI_CompareResult_Type.equal) {
+          // No changes detected, reuse existing document without saving
+          documentCompareResult.newDocument = existingDocument;
+          documentCompareResult.oldDocument = existingDocument;
+        } else {
+          // Changes detected, save the updated document
+          let docDataToSave: T_Document;
+          docDataToSave = existingDocument;
+          Object.assign(docDataToSave, document);
+          delete docDataToSave.pages;
+
+          const savedDocument: T_Document = await this.saveData(docDataToSave, true);
+
+          // set the id to the pages and the document
+          document.pages.forEach((page: T_Page) => {
+            page.documentId = savedDocument._id;
+          });
+          document._id = savedDocument._id;
+          documentCompareResult.newDocument = document;
+        }
       } else {
-        docDataToSave = {
+        // New document, save it first to get ID
+        const docDataToSave: T_Document = {
           ...document,
         };
-      };
-      delete docDataToSave.pages;
+        delete docDataToSave.pages;
 
-      const savedDocument: T_Document = await this.saveData(docDataToSave, true);
+        const savedDocument: T_Document = await this.saveData(docDataToSave, true);
 
-      // set the id to the pages and the document
-      document.pages.forEach((page: T_Page) => {
-        page.documentId = savedDocument._id;
-      });
-      document._id = savedDocument._id;
+        // set the id to the pages and the document
+        document.pages.forEach((page: T_Page) => {
+          page.documentId = savedDocument._id;
+        });
+        document._id = savedDocument._id;
 
-      let documentCompareResult: DyNTS_DAI_DocumentCompareResult<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata, T_Document>;
-      if (existingDocument) {
-        documentCompareResult = await this.compareDocument_deep(document, existingDocument);
-      } else {
         const docPage_DS: DyNTS_OAI_DocPageDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document> = 
           this.getDocPageDataService();
 
@@ -316,18 +326,34 @@ export class DyNTS_OAI_DocumentDataService<
         });
       }
 
-      let result: DyNTS_DAI_CompareResult_Type;
+      let result: DyNTS_DAI_CompareResult_Type = DyNTS_DAI_CompareResult_Type.equal;
       const messages: string[] = [];
 
-      if (!oldDocument) {
-        result = DyNTS_DAI_CompareResult_Type.new;
-        messages.push(`New document: "${newDocument.name}"`);
-      } else if (newDocument.name !== oldDocument?.name) {
+      // Compare document name
+      if (newDocument.name !== oldDocument.name) {
         result = DyNTS_DAI_CompareResult_Type.modified;
-        messages.push(`Document name changed from "${oldDocument?.name}" to "${newDocument.name}"`);
-      } else {
-        result = DyNTS_DAI_CompareResult_Type.equal;
-        messages.push(`Document name not changed: "${newDocument.name}"`);
+        messages.push(`Document name changed from "${oldDocument.name}" to "${newDocument.name}"`);
+      }
+
+      // Compare externalDocumentId
+      if (newDocument.externalDocumentId !== oldDocument.externalDocumentId) {
+        result = DyNTS_DAI_CompareResult_Type.modified;
+        messages.push(`Document externalDocumentId changed`);
+      }
+
+      // Compare externalMetadata if present
+      if (newDocument.externalMetadata || oldDocument.externalMetadata) {
+        const newMetadataStr = newDocument.externalMetadata ? JSON.stringify(newDocument.externalMetadata) : '';
+        const oldMetadataStr = oldDocument.externalMetadata ? JSON.stringify(oldDocument.externalMetadata) : '';
+        
+        if (newMetadataStr !== oldMetadataStr) {
+          result = DyNTS_DAI_CompareResult_Type.modified;
+          messages.push(`Document externalMetadata changed`);
+        }
+      }
+
+      if (result === DyNTS_DAI_CompareResult_Type.equal) {
+        messages.push(`Document name or not changed: "${newDocument.name}"`);
       }
 
       const result_flat: DyNTS_DAI_DocumentCompareResult<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata, T_Document> = {

package/src/_modules/assistant/_collections/ass-global-settings.const.ts

@@ -0,0 +1,13 @@
+import { DyNTS_Ass_Global_Settings } from '../_models/ass-global-settings.interface';
+
+export const DyNTS_Ass_global_settings: DyNTS_Ass_Global_Settings = {
+  defaultSystemPrompt: 'You are a helpful assistant.',
+  skipConversationMessagesFlags: [ 
+    '[NOISE]', 
+    '[VOICE|USER|OUTOFCONTEXT]', 
+    '[DEBUG|' 
+  ],
+  userTranslationFlags: [ 
+    '[VOICE|USER' 
+  ],
+};

package/src/_modules/assistant/_collections/ass.util.ts

@@ -0,0 +1,50 @@
+import { DyNTS_Bot_Message } from '../../bot/_models/bot-message.interface';
+import { DyFM_AI_Message, DyFM_AI_MessageRole } from '@futdevpro/fsm-dynamo/ai';
+import { DyNTS_Ass_global_settings } from './ass-global-settings.const';
+
+export class DyNTS_Ass_Util {
+  /**
+   * Convert bot messages (from any comms platform) to AI conversation format
+   * Uses EXISTING DyFM_AI_Message type from fsm-dynamo
+   * Same logic as DiAs_Util.convertDiscordMessagesToOAIConversation but platform-agnostic
+   */
+  static convertBotMessagesToAIConversation<T_BotMessage extends DyNTS_Bot_Message<any>>(
+    set: {
+      messages: T_BotMessage[],
+      botClientId: string,
+      botDisplayName: string,
+      issuer: string,
+    }
+  ): DyFM_AI_Message[] {
+    return set.messages.map(message => {
+      const isBot = (
+        message.isBot ||
+        message.authorId === set.botClientId ||
+        message.authorName === set.botDisplayName ||
+        message.authorDisplayName === set.botDisplayName
+      );
+      
+      if (isBot) {
+        // Check if bot message should be treated as user message
+        if (DyNTS_Ass_global_settings.userTranslationFlags.some(
+          flag => message.content.includes(flag)
+        )) {
+          return {
+            role: DyFM_AI_MessageRole.user,
+            content: message.content,
+          };
+        } else {
+          return {
+            role: DyFM_AI_MessageRole.assistant,
+            content: message.content,
+          };
+        }
+      } else {
+        return {
+          role: DyFM_AI_MessageRole.user,
+          content: message.content,
+        };
+      }
+    });
+  }
+}

package/src/_modules/assistant/_models/ass-global-settings.interface.ts

@@ -0,0 +1,15 @@
+export interface DyNTS_Ass_Global_Settings {
+  defaultSystemPrompt: string;
+  
+  /**
+   * These flags are used to skip messages from the conversation
+   * Default: [ '[NOISE]', '[VOICE|USER|OUTOFCONTEXT]', '[DEBUG|' ]
+   */
+  skipConversationMessagesFlags: string[];
+  
+  /**
+   * These flags identify bot messages that should be treated as user messages
+   * Default: [ '[VOICE|USER' ]
+   */
+  userTranslationFlags: string[];
+}

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,
+};