@futdevpro/nts-dynamo 1.14.28 → 1.14.31

package/src/_modules/ai/_modules/open-ai/_services/oai-llm-chat.service-base.ts

@@ -34,8 +34,41 @@ import {
 
 // Di Dictionary DiModel DiEz DiAz
 
-export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
+export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase implements DyNTS_AI_LLMChat_ServiceBase {
   
+  // History management
+  private conversationHistories: Map<string, DyFM_AI_Message[]> = new Map();
+
+  /**
+   * Hozzáad egy üzenetet a conversation history-hoz
+   * 
+   * Adds a message to conversation history
+   */
+  addMessageToHistory(message: DyFM_AI_Message, issuer: string): void {
+    if (!this.conversationHistories.has(issuer)) {
+      this.conversationHistories.set(issuer, []);
+    }
+    this.conversationHistories.get(issuer).push(message);
+  }
+
+  /**
+   * Törli a conversation history-t
+   * 
+   * Clears conversation history
+   */
+  clearHistory(issuer: string): void {
+    this.conversationHistories.delete(issuer);
+  }
+
+  /**
+   * Visszaadja a conversation history-t
+   * 
+   * Gets conversation history
+   */
+  getHistory(issuer: string): DyFM_AI_Message[] {
+    return this.conversationHistories.get(issuer) || [];
+  }
+
   /**
    * Converts generic AI messages to OpenAI-specific format
    * 
@@ -159,7 +192,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
    * 
    * Uses the {@link DyNTS_OAI_LLM_Predefined_Requests.multiselect} to ask the question
    */
-  async multipleSelectQuestionWithOptionsInConversation(set: DyFM_AI_ConversationMultiSelect_Input): Promise<string[]> {
+  async multipleSelectQuestionInConversationWithOptions(set: DyFM_AI_ConversationMultiSelect_Input): Promise<string[]> {
     const selectQuestionAddition = this.predefinedRequests.multiselect.replace(
       '{{DyNTS_selectOptions}}', 
       this.getTextListAsText(set.options)
@@ -189,7 +222,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
    * 
    * Uses the {@link DyNTS_OAI_LLM_Predefined_Requests.multiselect} to ask the question
    */
-  async requestMultipleSelectInConversation<T>(
+  async requestMultiselectInConversation<T>(
     set: DyFM_AI_ConversationGenericMultiSelect_Input<T>
   ): Promise<T[]> {
     const selectQuestionAddition = this.predefinedRequests.multiselect.replace(
@@ -226,6 +259,19 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
   }
   //askJsonQuestionInConversation: typeof this.jsonQuestionInConversation = this.jsonQuestionInConversation;
 
+  /**
+   * Asks the AI to answer a question that must result a JSON object with specific key descriptions
+   * 
+   * If the answer is not a valid JSON object, it will return { unparsableResult: answer }
+   * 
+   * Uses the {@link DyNTS_OAI_LLM_Predefined_Requests.jsonRequestWithKeysDescription} to ask the question
+   * 
+   * (uses {@link DyFM_safeParseJSON})
+   */
+  async JSONQuestionInConversationWithKeysDescription(set: DyFM_AI_ConversationJSONKeysDescription_Input): Promise<object> {
+    return this.jsonQuestionWithKeysDescriptionInConversation<any>(set);
+  }
+
   /**
    * Asks the AI to answer a question that must result a JSON object with specific key descriptions
    * 
@@ -252,6 +298,20 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
   }
   //askJsonQuestionWithKeysDescriptionInConversation: typeof this.jsonQuestionWithKeysDescriptionInConversation = this.jsonQuestionWithKeysDescriptionInConversation;
 
+  /**
+   * Asks the AI to answer a question that must result a JSON object with specific keys
+   * 
+   * If the answer is not a valid JSON object, it will return { unparsableResult: answer }
+   * 
+   * Uses the {@link DyNTS_OAI_LLM_Predefined_Requests.jsonRequestWithExactKeys} to ask the question
+   * 
+   * (uses {@link DyFM_safeParseJSON})
+   */
+  async JSONQuestionInConversationWithExactKeys(set: DyFM_AI_ConversationJSONExactKeys_Input): Promise<object> {
+    const result = await this.jsonQuestionWithExactKeysInConversation<any>(set);
+    return typeof result === 'object' ? result : {};
+  }
+
   /**
    * Asks the AI to answer a question that must result a JSON object with specific keys
    * 
@@ -536,4 +596,25 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
       });
     }
   }
+
+  /**
+   * Kérdez egy kérdést és JSON választ vár exact keys-szel
+   * 
+   * Asks a question and expects JSON response with exact keys
+   */
+  async requestJSONInConversationWithExactKeys<T>(
+    set: DyFM_AI_ConversationJSONExactKeys_Input
+  ): Promise<T> {
+    const answer = await this.jsonQuestionWithExactKeysInConversation<any>(set);
+    
+    if ('unparsableResult' in answer) {
+      throw new DyFM_Error({
+        message: 'Invalid JSON response from AI',
+        additionalContent: { answer },
+        userMessage: 'Failed to parse AI response'
+      });
+    }
+    
+    return answer as T;
+  }
 }

package/src/_modules/ai/_modules/open-ai/_services/oai-llm.service-base.ts

@@ -2,14 +2,33 @@ import { OpenAI } from 'openai';
 
 import { DyFM_OAI_Settings, DyFM_OAI_Model, DyFM_OAI_CallSettings } from '@futdevpro/fsm-dynamo/ai/open-ai';
 import { DyFM_AnyError, DyFM_Error, DyFM_Error_Settings, DyFM_Log, DyFM_notNull, DyFM_Object } from '@futdevpro/fsm-dynamo';
+import { 
+  DyFM_AI_Message, 
+  DyFM_AI_MessageRole,
+  DyFM_AI_Provider,
+  DyFM_AI_ProviderCapabilities,
+  DyFM_AI_CallSettings,
+  DyFM_AI_Config,
+  DyFM_AI_LLM_Response
+} from '@futdevpro/fsm-dynamo/ai';
 
 import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
-import { DyFM_AI_Message, DyFM_AI_MessageRole } from '@futdevpro/fsm-dynamo/ai';
 import { ChatCompletion } from 'openai/resources';
 import { ChatCompletionCreateParamsBase, ChatCompletionMessageParam } from 'openai/resources/chat/completions';
 import { DyNTS_OAI_LLM_Predefined_Requests } from '../_models/interfaces/oai-llm-predefined-requests.interface';
 import { DyNTS_OAI_global_settings } from '../_collections/oai-global-settings.const';
 import { DyNTS_OAI_LLMDefaultPredefined_Requests } from '../_collections/oai-llm-predefined-requests.conts';
+import { DyNTS_AI_LLM_ServiceBase } from '../../../_services/ai-llm.service-base';
+import {
+  DyFM_AI_Question_Input,
+  DyFM_AI_ListSelect_Input,
+  DyFM_AI_GenericSelect_Input,
+  DyFM_AI_MultiSelect_Input,
+  DyFM_AI_GenericMultiSelect_Input,
+  DyFM_AI_JSONKeysDescription_Input,
+  DyFM_AI_JSONExactKeys_Input,
+  DyFM_AI_SimpleMessage_Input
+} from '../../../_models/ai-input-interfaces';
 
 
 /**
@@ -22,18 +41,33 @@ import { DyNTS_OAI_LLMDefaultPredefined_Requests } from '../_collections/oai-llm
 
 // Di Dictionary DiModel DiEz DiAz
 
-export class DyNTS_OAI_LLM_ServiceBase {
+export class DyNTS_OAI_LLM_ServiceBase extends DyNTS_AI_LLM_ServiceBase {
     
-  readonly defaultErrorUserMsg: string = 
+  /* readonly defaultErrorUserMsg: string = 
     `We encountered an unhandled Control Service Error, ` +
-    `\nplease contact the responsible development team.`; 
+    `\nplease contact the responsible development team.`;  */
 
-  readonly openai: OpenAI;
+  openai: OpenAI;
 
-  /* readonly defaultSystemPrompt: string;
-  readonly defaultModel: DyFM_OAI_Model | string; */
   readonly defaultSettings: DyFM_OAI_CallSettings;
 
+  // Provider properties from DyNTS_AI_Provider_ServiceBase
+  readonly aiProvider: DyFM_AI_Provider = DyFM_AI_Provider.OpenAI;
+
+  readonly capabilities: DyFM_AI_ProviderCapabilities = {
+    chat: true,
+    embeddings: true,
+    imageGeneration: true,
+    vision: true,
+    audioGeneration: true,
+    audioAnalysis: true,
+    functionCalling: true,
+    streaming: true,
+    batchOperations: true,
+    maxContextLength: 128000,
+    supportedModelTypes: ['gpt-4o', 'gpt-4o-mini', 'text-embedding-3-large', 'text-embedding-3-small']
+  };
+
   get debugLog(): boolean {
     return this.defaultSettings.debugLog;
   }
@@ -52,6 +86,8 @@ export class DyNTS_OAI_LLM_ServiceBase {
   constructor(
     set?: DyFM_OAI_Settings
   ) {
+    super();
+    
     DyNTS_global_settings.openAi_settings ??= DyNTS_OAI_global_settings;
     
     this.openai = new OpenAI(
@@ -621,7 +657,7 @@ export class DyNTS_OAI_LLM_ServiceBase {
     });
   }
   
-  protected getDefaultErrorSettings(
+  /* protected getDefaultErrorSettings(
     fnName: string, 
     error: DyFM_AnyError,
     issuer: string
@@ -637,6 +673,205 @@ export class DyNTS_OAI_LLM_ServiceBase {
       issuerService: this.constructor?.name,
       error: error,
     };
+  } */
+
+  //#endregion
+
+  //#region Provider Methods (from DyNTS_AI_Provider_ServiceBase)
+
+  /**
+   * Inicializálja az OpenAI client-et a megadott config-gal
+   * 
+   * Reinitializes the OpenAI client with the provided config
+   */
+  initialize(config: DyFM_AI_Config): void {
+    this.openai = new OpenAI(config);
+  }
+
+  /**
+   * Teszteli a kapcsolatot az OpenAI API-val
+   * 
+   * Tests the connection to OpenAI API
+   */
+  async testConnection(issuer: string): Promise<boolean> {
+    try {
+      await this.openai.models.list();
+      return true;
+    } catch (error) {
+      DyFM_Log.error('DyNTS_OAI_LLM_ServiceBase', 'testConnection', 'Connection test failed', {
+        error,
+        issuer
+      });
+      return false;
+    }
+  }
+
+  //#endregion
+
+  //#region Abstract LLM Methods (from DyNTS_AI_LLM_ServiceBase)
+
+  /**
+   * Meghívja az LLM-et system és user message-szel
+   * 
+   * Calls the LLM with system and user messages
+   */
+  async callLLM(
+    systemMessage: string,
+    userMessage: string,
+    settings?: DyFM_AI_CallSettings,
+    issuer?: string
+  ): Promise<string> {
+    const result = await this.resolveMessage({
+      conversation: [
+        { role: DyFM_AI_MessageRole.system, content: systemMessage },
+        { role: DyFM_AI_MessageRole.user, content: userMessage }
+      ],
+      issuer: issuer ?? 'system',
+      settings: this.convertToOAISettings(settings),
+      getFullResponse: false
+    });
+    
+    if (typeof result === 'string') {
+      return result;
+    }
+    return '';
+  }
+
+  /**
+   * Meghívja az LLM-et üzenet history-val
+   * 
+   * Calls the LLM with message history
+   */
+  async callLLMWithHistory(
+    messages: DyFM_AI_Message[],
+    settings?: DyFM_AI_CallSettings,
+    issuer?: string
+  ): Promise<string> {
+    const result = await this.resolveMessage({
+      conversation: messages,
+      issuer: issuer ?? 'system',
+      settings: this.convertToOAISettings(settings),
+      getFullResponse: false
+    });
+    
+    if (typeof result === 'string') {
+      return result;
+    }
+    return '';
+  }
+
+  /**
+   * Meghívja az LLM-et és visszaadja a raw response-t
+   * 
+   * Calls the LLM and returns raw response
+   */
+  async callLLMRaw(
+    messages: DyFM_AI_Message[],
+    settings?: DyFM_AI_CallSettings,
+    issuer?: string
+  ): Promise<DyFM_AI_LLM_Response> {
+    const result = await this.resolveMessage({
+      conversation: messages,
+      issuer: issuer ?? 'system',
+      settings: this.convertToOAISettings(settings),
+      getFullResponse: true
+    }) as ChatCompletion;
+
+    return {
+      content: result.choices[0].message.content,
+      usage: result.usage ? {
+        promptTokens: result.usage.prompt_tokens,
+        completionTokens: result.usage.completion_tokens,
+        totalTokens: result.usage.total_tokens
+      } : undefined,
+      model: result.model,
+      finishReason: result.choices[0].finish_reason,
+      rawResponse: result
+    };
+  }
+
+  /**
+   * Küld egy egyszerű üzenetet az LLM-nek
+   * 
+   * Sends a simple message to the LLM
+   */
+  async sendMessage(set: DyFM_AI_SimpleMessage_Input): Promise<string> {
+    return await this.resolveSimpleUserMessage({
+      message: set.message,
+      issuer: set.issuer,
+      settings: set.settings ? this.convertToOAISettings(set.settings) : undefined
+    });
+  }
+
+  /**
+   * Kérdez egy kérdést és JSON választ vár exact keys-szel
+   * 
+   * Asks a question and expects JSON response with exact keys
+   */
+  async requestJSONWithExactKeys<T = any>(
+    set: DyFM_AI_JSONExactKeys_Input
+  ): Promise<T> {
+    const answer = await this.askJSONQuestionWithExactKeys({
+      question: set.question,
+      keys: set.keys,
+      issuer: set.issuer,
+      settings: set.settings ? this.convertToOAISettings(set.settings) : undefined,
+      debugLog: set.debugLog,
+      replaceThisInLog: set.replaceThisInLog
+    });
+
+    if ('unparsableResult' in answer) {
+      throw new DyFM_Error({
+        message: 'Invalid JSON response from AI',
+        additionalContent: { answer },
+        userMessage: 'Failed to parse AI response'
+      });
+    }
+
+    return answer as T;
+  }
+
+  /**
+   * Kérdez egy kérdést és több választ vár
+   * 
+   * Asks a question and expects multiple responses
+   */
+  async requestMultiselect<T = any>(
+    set: DyFM_AI_GenericMultiSelect_Input<T>
+  ): Promise<T[]> {
+    const answer = await this.requestMultipleSelect({
+      question: set.question,
+      options: set.options,
+      issuer: set.issuer,
+      settings: set.settings ? this.convertToOAISettings(set.settings) : undefined,
+      debugLog: set.debugLog,
+      replaceThisInLog: set.replaceThisInLog
+    });
+
+    return answer as T[];
+  }
+
+  /**
+   * Konvertálja a generic AI settings-et OpenAI specifikus settings-re
+   * 
+   * Converts generic AI settings to OpenAI-specific settings
+   */
+  private convertToOAISettings(settings?: DyFM_AI_CallSettings): DyFM_OAI_CallSettings {
+    if (!settings) return undefined;
+
+    const oaiSettings = new DyFM_OAI_CallSettings();
+    
+    if (settings.systemPrompt) oaiSettings.systemPrompt = settings.systemPrompt;
+    if (settings.useModel) oaiSettings.useModel = settings.useModel as DyFM_OAI_Model;
+    if (settings.project) oaiSettings.project = settings.project;
+    if (settings.debugLog !== undefined) oaiSettings.debugLog = settings.debugLog;
+    if (settings.temperature !== undefined) oaiSettings.temperature = settings.temperature;
+    if (settings.maxTokens !== undefined) oaiSettings.maxTokens = settings.maxTokens;
+    if (settings.topP !== undefined) oaiSettings.topP = settings.topP;
+    if (settings.frequencyPenalty !== undefined) oaiSettings.frequencyPenalty = settings.frequencyPenalty;
+    if (settings.presencePenalty !== undefined) oaiSettings.presencePenalty = settings.presencePenalty;
+
+    return oaiSettings;
   }
 
   //#endregion

package/src/_modules/ai/_modules/open-ai/index.ts

@@ -61,12 +61,13 @@ export * from './_services/oai-llm-chat.service';
 export * from './_services/oai-embedding.service'; */
 /* export * from './_services/oai-doc-chunk.service'; */
 
-// Legacy (for backward compatibility)
-export * from './_services/oai-doc-chunk-data.service';
-export * from './_services/oai-doc-page.data-service';
-export * from './_services/oai-document.data-service';
+// SERVICES
 export * from './_services/oai-embedding.control-service';
 export * from './_services/oai-llm-chat.service-base';
 export * from './_services/oai-llm.service-base';
-export * from './_services/oai-vector-data.service';
+// services/DATA-SERVICES
+export * from './_services/data-services/oai-doc-chunk-data.service';
+export * from './_services/data-services/oai-doc-page.data-service';
+export * from './_services/data-services/oai-document.data-service';
+export * from './_services/data-services/oai-vector-data.service';
 /* export * from './_services/oai-doc-chunk.service-base'; */

package/src/_modules/ai/_services/ai-llm.service-base.ts

@@ -69,11 +69,11 @@ export abstract class DyNTS_AI_LLM_ServiceBase extends DyNTS_AI_Provider_Service
   abstract sendMessage(set: DyFM_AI_SimpleMessage_Input): Promise<string>;
   
   // Helper methods
-  protected abstract getDefaultErrorSettings(
+  /* protected abstract getDefaultErrorSettings(
     method: string,
     error: any,
     issuer?: string
-  ): DyFM_Error_Settings;
+  ): DyFM_Error_Settings; */
   
   protected abstract getTextListAsText(list: string[]): string;
   

package/src/_modules/ai/_services/ai-provider.service-base.ts

@@ -1,12 +1,13 @@
 import { DyFM_AI_Provider } from '@futdevpro/fsm-dynamo/ai';
 import { DyFM_AI_ProviderCapabilities } from '@futdevpro/fsm-dynamo/ai';
 import { DyFM_AI_Config } from '@futdevpro/fsm-dynamo/ai';
+import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
 
 /**
  * Abstract base class for all AI providers
  * Defines the common interface that all AI providers must implement
  */
-export abstract class DyNTS_AI_Provider_ServiceBase {
+export abstract class DyNTS_AI_Provider_ServiceBase extends DyNTS_SingletonService {
   /** The AI provider this service represents */
   abstract readonly aiProvider: DyFM_AI_Provider;
   

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

@@ -1,4 +1,4 @@
-import { DyNTS_Bot_Message } from '../../bot/_models/bot-message.interface';
+import { DyNTS_Bot_MessageWrapper } from '../../bot/_models/bot-message-wrapper.interface';
 import { DyFM_AI_Message, DyFM_AI_MessageRole } from '@futdevpro/fsm-dynamo/ai';
 import { DyNTS_Ass_global_settings } from './ass-global-settings.const';
 
@@ -8,7 +8,7 @@ export class DyNTS_Ass_Util {
    * 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>>(
+  static convertBotMessagesToAIConversation<T_BotMessage extends DyNTS_Bot_MessageWrapper<any>>(
     set: {
       messages: T_BotMessage[],
       botClientId: string,

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

@@ -1,73 +1,45 @@
-import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyFM_Error } 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_MessageWrapper } from '../../bot/_models/bot-message-wrapper.interface';
-import { DyNTS_Bot_Channel } from '../../bot/_models/bot-channel.interface';
-import { DyNTS_Bot_User } from '../../bot/_models/bot-user.interface';
-import { DyNTS_Bot_MessagingProvider } from '../../bot/_models/bot-messaging-provider.interface';
-import { DyNTS_Ass_Main_ControlService } from './ass-main.control-service';
+/* 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';
+import { DyNTS_Ass_Main_ControlService } from './ass-main.control-service';
 
 /**
  * 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_MessagingProvider<
-    T_PlatformChannel, 
-    T_PlatformMessage, 
-    T_PlatformUser
-  > = DyNTS_Bot_MessagingProvider<
-    T_PlatformChannel, 
-    T_PlatformMessage, 
-    T_PlatformUser
-  >
-> extends DyNTS_Bot_IO_ControlService<T_PlatformChannel, T_PlatformMessage, T_PlatformUser, T_CommsProvider> {
+export abstract class DyNTS_Ass_IO_ControlService extends DyNTS_Bot_IO_ControlService {
 
-  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
-  >;
+  protected abstract override getMainBotControlService(): DyNTS_Ass_Main_ControlService;  
+  declare mainBot_CS: DyNTS_Ass_Main_ControlService;
   
   get aiProvider(): DyNTS_AI_LLMChat_ServiceBase {
-    return this.mainBot_CS?.aiProvider;
+    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, 
-    wrapper: DyNTS_Bot_MessageWrapper<T_PlatformMessage>,
+  async handleMessage(
+    message: DyNTS_Bot_MessageWrapper<any>,
     issuer: string
-  ): Promise<T_PlatformMessage> {
+  ): Promise<DyNTS_Bot_MessageWrapper<any>> {
     try {
       // Gather messages from comms platform using wrapper's provider
-      const messages: T_PlatformMessage[] = await this.mainBot_CS.gatherMessagesForMessage(message, wrapper);
+      const messages: DyNTS_Bot_MessageWrapper<any>[] = 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,
+          botClientId: message.provider.botId,
+          botDisplayName: message.provider.botDisplayName,
           issuer: issuer,
         });
       
@@ -81,19 +53,16 @@ export abstract class DyNTS_Ass_IO_ControlService<
       });
       
       // Reply via same provider the message came from
-      return await wrapper.provider.replyToMessage(message.id, message.channelId, aiResult);
+      return await message.provider.replyToMessage(message, aiResult);
     } catch (error) {
       DyFM_Error.logSimple('❌❌ Error handleMessage:', error);
       
       if (!this.dontSendErrorReply && DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
-        await wrapper.provider.replyToMessage(
-          message.id,
-          message.channelId,
+        await message.provider.replyToMessage(
+          message,
           `[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({