@futdevpro/nts-dynamo 1.10.77 → 1.11.2

package/src/_collections/sample.env

@@ -0,0 +1,21 @@
+
+
+ENV={REPLACE_ENV}
+
+MONGO_URI={REPLACE_ATLASDB_URI}
+
+DISCORD_TOKEN={REPLACE_DISCORD_TOKEN}
+DISCORD_CLIENT_ID={REPLACE_DISCORD_CLIENT_ID}
+DISCORD_GUILD_ID={REPLACE_DISCORD_GUILD_ID}
+DISCORD_OAUTH2_URL={REPLACE_DISCORD_OAUTH2_URL}
+
+OPENAI_API_KEY={REPLACE_OPENAI_API_KEY}
+OPENAI_ORGANIZATION={REPLACE_OPENAI_ORGANIZATION}
+OPENAI_PROJECT={REPLACE_OPENAI_PROJECT}
+OPENAI_TTS_API_KEY={REPLACE_OPENAI_TTS_API_KEY}
+
+ELEVENLABS_API_KEY={REPLACE_ELEVENLABS_API_KEY}
+
+CLICKUP_TOKEN={REPLACE_CLICKUP_TOKEN}
+CLICKUP_WORKSPACE_ID={REPLACE_CLICKUP_WORKSPACE_ID}
+CLICKUP_SPACE_ID={REPLACE_CLICKUP_SPACE_ID}

package/src/_models/control-models/app-params.control-model.spec.ts

@@ -21,14 +21,15 @@ describe('| DyNTS_App_Params', () => {
     expect(appParams.dbName).toBe('testdb');
     expect(appParams.dbUri).toBe('mongodb://0.0.0.0:27017/testdb');
     expect(appParams.systemName).toBe('Test-App');
-    expect(appParams.systemShortCodeName).toBe('TA');
+    expect(appParams.systemShortCodeName).toBe('TA_LOCAL');
   });
 
   it('| should set default values when optional parameters are not provided', () => {
     const params: DyNTS_App_Params = {
       name: 'TestApp',
       version: '1.0.0',
-      dbName: 'testdb'
+      dbName: 'testdb',
+      dontUseEnvInSystemShortCodeName: true,
     };
 
     const appParams = new DyNTS_App_Params(params);
@@ -47,12 +48,12 @@ describe('| DyNTS_App_Params', () => {
       name: 'Test Application',
       version: '1.0.0',
       dbName: 'testdb',
-      systemName: 'Test-App'
+      systemName: 'Test-App',
     };
 
     const appParams = new DyNTS_App_Params(params);
 
-    expect(appParams.systemShortCodeName).toBe('TA');
+    expect(appParams.systemShortCodeName).toBe('TA_LOCAL');
   });
 
   it('| should generate systemName from name if not provided', () => {

package/src/_models/control-models/app-params.control-model.ts

@@ -1,5 +1,6 @@
 import { DyFM_Log } from '@futdevpro/fsm-dynamo';
 import { ConnectOptions } from 'mongoose';
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
 
 /**
  * This will hold and set the basic settings of an application
@@ -37,6 +38,11 @@ export class DyNTS_App_Params {
 
   readonly openHost?: string;
   readonly secureHost?: string;
+  /** 
+   * specify the maximum
+   * length of the queue of pending connections. 
+   * The actual length will be determined by the OS through sysctl.
+   * */
   readonly expressBacklog?: number;
 
   /**
@@ -47,6 +53,7 @@ export class DyNTS_App_Params {
    * short code name of the system
    */
   readonly systemShortCodeName?: string;
+  readonly dontUseEnvInSystemShortCodeName?: boolean;
 
   constructor(
     set: DyNTS_App_Params
@@ -54,15 +61,37 @@ export class DyNTS_App_Params {
     this.name = set.name;
     this.title = set.title ?? '';
     this.version = set.version;
+
     if (set.dbName || set.dbUri || set.dbOptions) {
       this.dbName = set.dbName;
-      this.dbUri = set.dbUri ?? `mongodb://0.0.0.0:27017/${this.dbName}`;
+
+      if (!set.dbUri) {
+        if (DyNTS_global_settings.env_settings.mongoUri) {
+          if (set.dbName) {
+            this.dbUri = `${DyNTS_global_settings.env_settings.mongoUri}/${set.dbName}`;
+          } else {
+            this.dbUri = DyNTS_global_settings.env_settings.mongoUri;
+          }
+        } else {
+          this.dbUri = `mongodb://0.0.0.0:27017/${set.dbName}`;
+        }
+      } else {
+        this.dbUri = set.dbUri;
+      }
+
       this.dbOptions = set.dbOptions ?? {
         directConnection: true,
       };
     }
+    
     this.systemName = set.systemName ?? this.name.replace(' ', '-');
-    this.systemShortCodeName = set.systemShortCodeName ?? this.systemName.replace(/[^A-Z]/g, '');
+    let sysShortCodeName: string;
+    sysShortCodeName = set.systemShortCodeName ?? this.systemName.replace(/[^A-Z]/g, '');
+    if (!set.dontUseEnvInSystemShortCodeName) {
+      sysShortCodeName += '_' + DyNTS_global_settings.env_settings.environment.toUpperCase();
+    }
+    this.systemShortCodeName = sysShortCodeName;
+
     this.openHost = set.openHost ?? '0.0.0.0';
     this.secureHost = set.secureHost ?? '0.0.0.0';
     this.expressBacklog = set.expressBacklog ?? 0;

package/src/_models/control-models/endpoint-params.control-model.ts

@@ -348,7 +348,7 @@ export class DyNTS_Endpoint_Params<
       }
 
       if (
-        DyNTS_global_settings.environment === DyFM_EnvironmentFlag.prod &&
+        DyNTS_global_settings.env_settings.environment === DyFM_EnvironmentFlag.prod &&
         error instanceof DyFM_Error
       ) {
         delete (error as DyFM_Error).confidentialContent;

package/src/_models/interfaces/environment-settings.interface.ts

@@ -0,0 +1,59 @@
+import { DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
+
+
+
+export interface DyNTS_Environment_Settings {
+  /**
+   * this is the environment flag of the system
+   * e.g. local, development, production
+   * 
+   * use ENV or ENVIRONMENT in the .env file to set the environment
+   * 
+   * use {@link DyFM_EnvironmentFlag} for consistent system processes
+   */
+  environment: DyFM_EnvironmentFlag;
+
+  /**
+   * this is the discord settings of the system
+   */
+  discord: {
+    token: string;
+    clientId: string;
+    guildId: string;
+    oauth2Url: string;
+  },
+
+  /**
+   * this is the mongo uri of the system
+   */
+  mongoUri: string;
+
+  /**
+   * this is the openai settings of the system
+   */
+  openAi: {
+    apiKey: string;
+    organization: string;
+    project: string;
+    ttsApiKey: string;
+  },
+
+  /**
+   * this is the elevenlabs settings of the system
+   */
+  /* elevenLabs: {
+    apiKey: string;
+  }, */
+
+  /**
+   * this is the clickup settings of the system
+   */
+  /* clickup: {
+    apiKey: string;
+    workspaceId: string;
+    spaceId: string;
+    listId: string;
+  }, */
+
+}
+

package/src/_models/interfaces/global-settings.interface.ts

@@ -2,6 +2,7 @@ import { DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
 import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
 import { DyNTS_SocketSecurity } from '../../_modules/socket/_enums/socket-security.enum';
 import { DyNTS_GlobalLog_Settings } from './global-log-settings.interface';
+import { DyNTS_Environment_Settings } from './environment-settings.interface';
 
 /**
  * 
@@ -12,6 +13,9 @@ import { DyNTS_GlobalLog_Settings } from './global-log-settings.interface';
  * 
  */
 export interface DyNTS_Global_Settings {
+
+  env_settings: DyNTS_Environment_Settings;
+
   /**
    * this will be used as the main baseUrl for the application,
    * this is not required, but we suggest to use at least a '/api' as base route
@@ -59,7 +63,7 @@ export interface DyNTS_Global_Settings {
   /**
    * this is the environment of the system
    */
-  environment: DyFM_EnvironmentFlag;
+  /* environment: DyFM_EnvironmentFlag; */
 
   /**
    * this setting will set which logs will be shown
@@ -70,4 +74,40 @@ export interface DyNTS_Global_Settings {
    * this setting will set the research issues mode for the system
    */
   autoResearchIssues: boolean;
+
+  /**
+   * this setting will set the bot settings
+   * (this will be set in the {@link DyNTS_DiBo_Main_ControlService} constructor)
+   * 
+   * {@link DyNTS_GlobalBot_Settings}
+   * default settings: {@link DyNTS_DiBo_Global_Settings}
+   */
+  bot_settings: any;
+
+  /**
+   * this setting will set the openai settings
+   * (this will be set in the {@link DyNTS_OAI_LLMChat_ServiceBase} constructor)
+   * 
+   * {@link DyNTS_OpenAI_Settings}
+   * default settings: {@link DyNTS_OAI_global_settings}
+   */
+  openAi_settings: any;
+
+  /**
+   * this setting will set the dias settings
+   * (this will be set in the {@link DyNTS_OAI_LLM_ServiceBase} constructor, if not set already)
+   * ({@link DyNTS_OAI_VectorDataService} is not using this, but its own settings)
+   * 
+   * {@link DyNTS_DiAs_Global_Settings}
+   * default settings: {@link DyNTS_DiAs_Global_Settings}
+   */
+  dias_settings: any;
+
+  /**
+   * this setting will set the doc chunking settings
+   */
+  docChunking: {
+    maxChunkSize: number;
+    maxChunkCount: number;
+  };
 }

package/src/_modules/custom-data/index.ts

@@ -1,4 +1,7 @@
 
+
+// This module is implementing contains sample and experimental custom-data solutions.
+
 // CUSTOM-DATA MODULE
 export * from './custom-data.data-service';
 export * from './get-custom-data-routing-module.util';

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

@@ -0,0 +1,19 @@
+import { DyNTS_OAI_LLMDefaultPredefined_Requests } from '../../open-ai/_collections/oai-llm-predefined-requests.conts';
+import { DyNTS_DiAs_Global_Settings } from '../_models/dias-global-settings.interface';
+
+
+export const DyNTS_DiAs_global_settings: DyNTS_DiAs_Global_Settings = {
+  defaultSystemPrompt: 
+    DyNTS_OAI_LLMDefaultPredefined_Requests.defaultSystemPrompt +
+    'You communicate via a multi-user interface, such as a Discord channel. ',
+
+  skipConversationMessagesFlags: [
+    '|NOISE]',
+    '[VOICE|USER|OUT_OF_CONTEXT]',
+    '[DEBUG|'
+  ],
+  userTranslationFlags: [
+    '[VOICE|USER',
+  ],
+}
+

package/src/_modules/discord-assistant/_collections/dias.util.ts

@@ -0,0 +1,43 @@
+import { Message } from 'discord.js';
+import { DyNTS_OAI_GPT_Message } from '../../open-ai/_models/interfaces/oai-gpt-message.interface';
+import { DyNTS_DiAs_global_settings } from './dias-global-settings.const';
+import { DyNTS_OAI_GPT_Message_Role } from '../../open-ai';
+
+
+export class DyNTS_DiAs_Util {
+
+  static convertDiscordMessagesToOAIConversation(
+    messages: Message[],
+    botClientId: string,
+    botDisplayName: string,
+  ): DyNTS_OAI_GPT_Message[] {
+
+    return messages.map(message => {
+      if (
+        (message?.author &&
+          (message.author.bot || 
+            message.author.id === botClientId ||
+            message.author.displayName === botDisplayName))
+      ) {
+        if (DyNTS_DiAs_global_settings.userTranslationFlags.some(
+          flag => message.content.includes(flag)
+        )) {
+          return {
+            role: DyNTS_OAI_GPT_Message_Role.user,
+            content: message.content,
+          };
+        } else {
+          return {
+            role: DyNTS_OAI_GPT_Message_Role.assistant,
+            content: message.content,
+          };
+        }
+      } else {
+        return {
+          role: DyNTS_OAI_GPT_Message_Role.user,
+          content: message.content,
+        };
+      }
+    })
+  }
+}

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

@@ -0,0 +1,20 @@
+
+
+export interface DyNTS_DiAs_Global_Settings {
+  defaultSystemPrompt: string;
+
+  /**
+   * These flags are used to skip messages from the conversation
+   * so these messages will not be included in the conversation for the LLM call
+   * 
+   * default: [ '|NOISE]', '[VOICE|USER|OUT_OF_CONTEXT]', '[DEBUG|' ]
+   */
+  skipConversationMessagesFlags: string[];
+  /**
+   * These flags are used to identify messages that are sent by the bot, but comes from the user
+   * so these messages will appear as user messages in the conversation for the LLM call
+   * 
+   * default: [ '[VOICE|USER' ]
+   */
+  userTranslationFlags: string[];
+}

package/src/_modules/discord-assistant/_models/dias-knowledge.data-model.ts

@@ -0,0 +1,46 @@
+import { DyFM_DataModel_Params, DyFM_Metadata } from '@futdevpro/fsm-dynamo';
+
+
+
+export class DyNTS_DiAs_Knowledge extends DyFM_Metadata {
+
+  subject?: string;
+  subjectVectorized?: number[] = [];
+
+  description?: string;
+  descriptionVectorized?: number[] = [];
+
+  constructor(
+    set?: DyNTS_DiAs_Knowledge,
+  ) {
+    super(set);
+
+    if (set) {
+      Object.assign(this, set);
+    }
+  }
+}
+
+export const DyNTS_DiAs_knowledge_dataParams = new DyFM_DataModel_Params<DyNTS_DiAs_Knowledge>({
+  dataName: 'dias_knowledge',
+  properties: {
+    subject: { 
+      type: 'string', index: true,
+      required: true, unique: true,
+    },
+    subjectVectorized: { 
+      type: 'number[]', 
+      vectorizedFrom: 'subject',
+      vectorizeUseIndex: 'subject',
+    },
+    description: { 
+      type: 'string', index: true,
+      required: true,
+    },
+    descriptionVectorized: { 
+      type: 'number[]', 
+      vectorizedFrom: 'description',
+      vectorizeUseIndex: 'description',
+    },
+  },
+});

package/src/_modules/discord-assistant/_services/dias-chunk.data-service.ts

@@ -0,0 +1,152 @@
+
+import { DyNTS_OAI_DocChunk } from '../../open-ai/_models/oai-doc-chunk.data-model';
+import { DyNTS_OAI_Chunk_ServiceBase } from '../../open-ai/_services/oai-chunk.service-base';
+import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyFM_OpenAI_Settings, DyFM_OpenAIModel } from '@futdevpro/fsm-dynamo/open-ai';
+import { DyNTS_DiAs_Main_ControlService } from './dias-main.control-service';
+import { DyNTS_OAI_LLMChat_ServiceBase } from '../../open-ai/_services/oai-llm-chat.service-base';
+import { DyNTS_OAI_GPT_Message } from '../../open-ai/_models/interfaces/oai-gpt-message.interface';
+import { DyNTS_OAI_LLMDefaultPredefined_Requests } from '../../open-ai/_collections/oai-llm-predefined-requests.conts';
+import { DyNTS_OAI_Document_Util } from '../../open-ai/_collections/oai-document.util';
+
+
+export abstract class DyNTS_DiAs_Chunk_DataService extends DyNTS_OAI_Chunk_ServiceBase {
+
+  protected abstract readonly mainDiscordBot_CS: DyNTS_DiAs_Main_ControlService;
+
+  get llmChat_CS(): DyNTS_OAI_LLMChat_ServiceBase {
+    return this.mainDiscordBot_CS.llmChat_CS;
+  }
+
+  constructor(
+    issuer: string,
+  ) {
+    super(issuer);
+  }
+
+  async resolveConversation(
+    conversation: DyNTS_OAI_GPT_Message[],
+  ): Promise<string> {
+    try {
+      DyFM_Log.info('🔍 Document message received:', conversation[conversation.length - 1].content);
+
+      const vectorSearchNeeded: boolean = await this.llmChat_CS.yesNoQuestionInConversation(
+        conversation,
+        DyNTS_OAI_LLMDefaultPredefined_Requests.vectorSearch.doWeNeedVectorSearch,
+        this.issuer,
+        false,
+        {
+          systemPrompt: DyNTS_OAI_LLMDefaultPredefined_Requests.defaultSystemPrompt,
+        },
+      );
+
+      let result: string;
+      if (vectorSearchNeeded) {
+        result = await this.vectorSearchAndResolveConversation(conversation, 10, 200);
+      } else {
+        result = await this.llmChat_CS.resolveConversation(
+          conversation,
+          this.issuer,
+          {
+            systemPrompt: DyNTS_OAI_LLMDefaultPredefined_Requests.defaultSystemPrompt,
+          },
+        ) as string;
+      }
+
+      return result;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('resolveMessage', error),
+        errorCode: 'QDB-DCHDS-RM0',
+      });
+    }
+  }
+
+  // TODO 
+  // add code overview by coding policies 
+  //  (Milyen jellegű coding policies lehet releváns az adott kérdésben)
+  async vectorSearchAndResolveConversation(
+    conversation: DyNTS_OAI_GPT_Message[],
+    limit: number = 3,
+    numberOfCandidates: number = 100,
+  ): Promise<string> {
+    try {
+      const searchResults: DyNTS_OAI_DocChunk[] = await this.vectorSearchUsingConversation(
+        conversation,
+        limit,
+        numberOfCandidates,
+      );
+
+      const parsedSearchResults: string = searchResults.map((result) => {
+        return '' +
+          '\npage: ' + result.documentName +
+          '\npageLink: ' + DyNTS_OAI_Document_Util.getClickupPageLink(
+            result.documentName,
+            result.workspaceId,
+            result.documentId,
+            result.documentPageId
+          ) +
+          '\ncontent: ' +
+          `\n${result.chunkParentedContent.replace(/\n/g, '\n  ')}`
+      }).join('\n\n');
+
+      DyFM_Log.H_success(`✅ Document search results:`, parsedSearchResults);
+      
+      const result: string = await this.llmChat_CS.resolveConversation(
+        conversation,
+        this.issuer,
+        {
+          systemPrompt: 
+            DyNTS_OAI_LLMDefaultPredefined_Requests.defaultSystemPrompt +
+            DyNTS_OAI_LLMDefaultPredefined_Requests.vectorSearch.resolveSearchResults +
+            parsedSearchResults,
+        }
+      ) as string;
+
+      return result;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('searchInfoInDocumentsAndAnswer', error),
+        errorCode: 'QDB-DCHDS-SIIA0',
+      });
+    }
+  }
+
+  // TODO: EZT KELL HÍVNI PARANCSRA 
+  async vectorSearchUsingConversation(
+    conversation: DyNTS_OAI_GPT_Message[],
+    limit: number = 3,
+    numberOfCandidates: number = 100,
+  ): Promise<DyNTS_OAI_DocChunk[]> {
+    try {
+      const lastMessage: DyNTS_OAI_GPT_Message = conversation[conversation.length - 1];
+
+      const searchQuestion: string = await this.llmChat_CS.getAnswerInConversation(
+        conversation,
+        DyNTS_OAI_LLMDefaultPredefined_Requests.vectorSearch.getSearchQuestion,
+        this.issuer,
+        {
+          systemPrompt: 
+            DyNTS_OAI_LLMDefaultPredefined_Requests.defaultSystemPrompt +
+            DyNTS_OAI_LLMDefaultPredefined_Requests.vectorSearch.systemPrompt,
+        },
+      );
+
+      DyFM_Log.testInfo('🔍 Document search question:', searchQuestion);
+
+      const searchResults: DyNTS_OAI_DocChunk[] = await this.vectorSearch(
+        searchQuestion + ' ' + lastMessage.content,
+        'chunkParentedContentVectorized',
+        limit,
+        numberOfCandidates,
+      )
+
+      return searchResults;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('vectorSearchUsingConversation', error),
+        errorCode: 'QDB-DCHDS-VSUC0',
+      });
+    }
+  }
+}

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

@@ -0,0 +1,64 @@
+import { Client, GatewayIntentBits, Guild, Collection, GuildMember, Message, TextChannel } from 'discord.js'
+import * as dotenv from 'dotenv'
+import { DyFM_Error, DyFM_Log, hour, week } from '@futdevpro/fsm-dynamo'
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const'
+import { DyNTS_DiBo_IO_ControlService } from '../../discord-bot'
+import { DyNTS_DiAs_Main_ControlService } from './dias-main.control-service'
+import { DyNTS_DiBo_global_settings } from '../../discord-bot/_collections/dibo-global-settings.conts'
+import { DyNTS_OAI_LLMChat_ServiceBase } from '../../open-ai/_services/oai-llm-chat.service-base'
+import { DyNTS_OAI_GPT_Message } from '../../open-ai/_models/interfaces/oai-gpt-message.interface'
+import { DyNTS_DiAs_Util } from '../_collections/dias.util'
+
+export abstract class DyNTS_DiAs_IO_ControlService extends DyNTS_DiBo_IO_ControlService {
+
+  /* static override getInstance(): DyNTS_DiAs_IO_ControlService {
+    return DyNTS_DiAs_IO_ControlService.getSingletonInstance();
+  } */
+  
+  /* abstract override getMainDiscordBotControlService(): DyNTS_DiAs_Main_ControlService; */
+  protected abstract override readonly mainDiscordBot_CS: DyNTS_DiAs_Main_ControlService;
+  /*  = 
+    this.getMainDiscordBotControlService(); */
+
+  get llmChat_CS(): DyNTS_OAI_LLMChat_ServiceBase {
+    return this.mainDiscordBot_CS.llmChat_CS;
+  }
+
+  override async handleMessage(message: Message, issuer: string): Promise<void> {
+    try {
+      const messages: Message[] = await this.mainDiscordBot_CS.gatherMessages(message);
+      const oaiMessages: DyNTS_OAI_GPT_Message[] = 
+        DyNTS_DiAs_Util.convertDiscordMessagesToOAIConversation(
+          messages,
+          this.mainDiscordBot_CS.botClientId,
+          this.mainDiscordBot_CS.botDisplayName,
+        );
+
+      const gptResult: string = await this.llmChat_CS.resolveConversation(
+        oaiMessages,
+        issuer,
+        { 
+          systemPrompt: this.mainDiscordBot_CS.defaultSystemPrompt,
+        }
+      ) as string;
+
+      await message.reply(gptResult);
+    } catch (error) {
+      DyFM_Error.logSimple('❌❌ Error handleNewMessage:', error);
+
+      if (DyNTS_DiBo_global_settings.debugLevel >= 1) {
+        await message.reply(
+          `[SYSTEM|ERROR] Error occurred while handling the message:\n` +
+          DyFM_Error.getAnyMessage(error)
+        ).catch(error => {
+          DyFM_Error.logSimple('❌❌ Error sending message to report channel:', error);
+        });
+      }
+
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('handleMessage', error, issuer),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiAs-IOCS-H0`,
+      })
+    }
+  }
+}

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

@@ -0,0 +1,28 @@
+
+import { DyFM_Error, DyFM_Log, DyFM_clone, DyFM_wait } from '@futdevpro/fsm-dynamo';
+import { Channel, Message, Role, TextChannel } from 'discord.js';
+import { DyNTS_DiBo_Main_ControlService } from '../../discord-bot/_services/dibo-main.control-service';
+import { DyNTS_DiAs_ServiceBase } from './dias.service-base';
+import { DyNTS_DiAs_IO_ControlService } from './dias-io.control-service';
+import { DyNTS_global_settings } from '../../..';
+
+
+export abstract class DyNTS_DiAs_Main_ControlService extends DyNTS_DiAs_ServiceBase {
+  
+  protected abstract override botIO_CS: DyNTS_DiAs_IO_ControlService;
+  protected abstract override getBotIOControlService(): DyNTS_DiAs_IO_ControlService;
+
+  override async start(issuer: string): Promise<void> {
+    try {
+      await super.start(issuer);
+
+      this.botIO_CS = this.getBotIOControlService();
+    } catch (error) {
+      DyFM_Error.logSimple('❌❌ Error start:', error);
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('start', error, 'system-init'),
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiAs-MCS-S0`,
+      })
+    }
+  }
+}