@futdevpro/nts-dynamo 1.14.35 → 1.14.37

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

@@ -1,21 +1,23 @@
 import { DyNTS_AI_LLM_ServiceBase } from './ai-llm.service-base';
-import { DyFM_AI_Message } from '@futdevpro/fsm-dynamo/ai';
+import { DyFM_AI_Message, DyFM_AI_CallSettings } from '@futdevpro/fsm-dynamo/ai';
 import {
-  DyFM_AI_ConversationQuestion_Input,
+  DyFM_AI_ConversationBase_Input,
   DyFM_AI_ConversationSelect_Input,
   DyFM_AI_ConversationGenericSelect_Input,
   DyFM_AI_ConversationMultiSelect_Input,
   DyFM_AI_ConversationGenericMultiSelect_Input,
   DyFM_AI_ConversationJSONKeysDescription_Input,
   DyFM_AI_ConversationJSONExactKeys_Input,
-  DyFM_AI_ConversationGetAnswer_Input
 } from '../_models/ai-input-interfaces';
+import { DyFM_getLocalStackLocation, DyFM_Log } from '@futdevpro/fsm-dynamo';
 
 /**
  * Abstract base class for LLM Chat services
  * Extends LLM service with conversation management capabilities
  */
-export abstract class DyNTS_AI_LLMChat_ServiceBase extends DyNTS_AI_LLM_ServiceBase {
+export abstract class DyNTS_AI_LLMChat_ServiceBase<
+  T_AISettings extends DyFM_AI_CallSettings = DyFM_AI_CallSettings
+> extends DyNTS_AI_LLM_ServiceBase<T_AISettings> {
   // History management
   /**
    * Add a message to the conversation history
@@ -33,16 +35,34 @@ export abstract class DyNTS_AI_LLMChat_ServiceBase extends DyNTS_AI_LLM_ServiceB
   /* abstract getHistory(issuer: string): DyFM_AI_Message[]; */
   
   // Conversation methods (from OAI_LLMChat_ServiceBase)
-  abstract yesNoQuestionInConversation(set: DyFM_AI_ConversationQuestion_Input): Promise<boolean>;
-  abstract simpleQuestionInConversation(set: DyFM_AI_ConversationQuestion_Input): Promise<string>;
-  abstract percentageQuestionInConversation(set: DyFM_AI_ConversationQuestion_Input): Promise<number>;
-  abstract selectQuestionInConversation(set: DyFM_AI_ConversationSelect_Input): Promise<string>;
-  abstract requestSelectInConversation<T>(set: DyFM_AI_ConversationGenericSelect_Input<T>): Promise<T | { unparsableResult: string }>;
-  abstract multipleSelectQuestionInConversationWithOptions(set: DyFM_AI_ConversationMultiSelect_Input): Promise<string[]>;
-  abstract requestMultiselectInConversation<T>(set: DyFM_AI_ConversationGenericMultiSelect_Input<T>): Promise<T[]>;
-  abstract JSONQuestionInConversationWithKeysDescription(set: DyFM_AI_ConversationJSONKeysDescription_Input): Promise<object>;
-  abstract JSONQuestionInConversationWithExactKeys(set: DyFM_AI_ConversationJSONExactKeys_Input): Promise<object>;
-  abstract requestJSONInConversationWithExactKeys<T>(set: DyFM_AI_ConversationJSONExactKeys_Input): Promise<T>;
-  abstract getQuestionAnswerInConversation(set: DyFM_AI_ConversationQuestion_Input): Promise<string>;
-  abstract getAnswerInConversation(set: DyFM_AI_ConversationGetAnswer_Input): Promise<string>;
+  abstract requestSimpleMessageInConversation(set: DyFM_AI_ConversationBase_Input<T_AISettings>): Promise<string>;
+  abstract requestYesNoInConversation(set: DyFM_AI_ConversationBase_Input<T_AISettings>): Promise<boolean>;
+  abstract requestPercentageInConversation(set: DyFM_AI_ConversationBase_Input<T_AISettings>): Promise<number>;
+
+  /* abstract selectQuestionInConversation(set: DyFM_AI_ConversationSelect_Input): Promise<string>; */
+  abstract requestSelectInConversation<T>(
+    set: DyFM_AI_ConversationGenericSelect_Input<T, T_AISettings>
+  ): Promise<T | { unparsableResult: string }>;
+  /* abstract multipleSelectQuestionInConversationWithOptions(
+    set: DyFM_AI_ConversationMultiSelect_Input<T_AISettings>
+  ): Promise<string[]>; */
+  abstract requestMultiselectInConversation<T>(
+    set: DyFM_AI_ConversationGenericMultiSelect_Input<T, T_AISettings>
+  ): Promise<T[] | { unparsableResult: string }>;
+
+  abstract requestJSONInConversation<T = any>(
+    set: DyFM_AI_ConversationBase_Input<T_AISettings>
+  ): Promise<T | { unparsableResult: string }>;
+  abstract requestJSONInConversationWithKeysDescription<T>(
+    set: DyFM_AI_ConversationJSONKeysDescription_Input<T_AISettings>
+  ): Promise<T | { unparsableResult: string }>;
+  abstract requestJSONInConversationWithExactKeys<T>(
+    set: DyFM_AI_ConversationJSONExactKeys_Input<T_AISettings>
+  ): Promise<T | { unparsableResult: string }>;
+  //abstract getQuestionAnswerInConversation(set: DyFM_AI_ConversationQuestion_Input): Promise<string>;
+  //abstract getAnswerInConversation(set: DyFM_AI_ConversationGetAnswer_Input): Promise<string>;
+
+  abstract requestListInConversation(
+    set: DyFM_AI_ConversationBase_Input<T_AISettings>
+  ): Promise<string[] | { unparsableResult: string }>;
 }

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

@@ -1,72 +1,101 @@
 import { DyNTS_AI_Provider_ServiceBase } from './ai-provider.service-base';
-import { DyFM_AI_CallSettings, DyFM_AI_Message, DyFM_AI_LLM_Response } from '@futdevpro/fsm-dynamo/ai';
-import { DyFM_Error_Settings } from '@futdevpro/fsm-dynamo';
+import { DyFM_AI_CallSettings, DyFM_AI_Message, DyFM_AI_LLM_Response, DyFM_AI_MessageRole } from '@futdevpro/fsm-dynamo/ai';
+import { DyFM_Error, DyFM_Error_Settings, DyFM_getLocalStackLocation, DyFM_Log, DyFM_Object } from '@futdevpro/fsm-dynamo';
 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
+  DyFM_AI_Message_Input,
 } from '../_models/ai-input-interfaces';
+import { Items } from 'openai/resources/conversations/items';
 
 /**
  * Abstract base class for LLM services
  * Defines all methods that must be implemented by AI providers
  */
-export abstract class DyNTS_AI_LLM_ServiceBase extends DyNTS_AI_Provider_ServiceBase {
+export abstract class DyNTS_AI_LLM_ServiceBase<
+  T_AISettings extends DyFM_AI_CallSettings = DyFM_AI_CallSettings
+> extends DyNTS_AI_Provider_ServiceBase {
   /** Default settings for LLM calls */
-  abstract readonly defaultSettings: DyFM_AI_CallSettings;
+  abstract readonly defaultSettings: T_AISettings;
   
   /** Default model to use for LLM calls */
-  abstract readonly defaultModel: string;
+  /* abstract readonly defaultModel: string; */
   
   /** Provider-specific predefined requests */
   abstract readonly predefinedRequests: any;
+
+  _debugLog: boolean = false;
+  get debugLog(): boolean {
+    return this.defaultSettings?.debugLog ?? this._debugLog;
+  }
+
+  get defaultSystemPrompt(): string {
+    return this.defaultSettings.systemPrompt;
+  }
+
+  get defaultModel(): string {
+    return this.defaultSettings.useModel;
+  }
+
+  defaultLogReplacer: string = '...long-context...';
   
   // Core abstract methods
   /**
    * Call LLM with system and user messages
    */
-  abstract callLLM(
+  /* abstract callLLM(
     systemMessage: string,
     userMessage: string,
     settings?: DyFM_AI_CallSettings,
     issuer?: string
-  ): Promise<string>;
+  ): Promise<string>; */
   
   /**
    * Call LLM with message history
    */
-  abstract callLLMWithHistory(
+  /* abstract callLLMWithHistory(
     messages: DyFM_AI_Message[],
     settings?: DyFM_AI_CallSettings,
     issuer?: string
-  ): Promise<string>;
+  ): Promise<string>; */
   
   /**
    * Call LLM and return raw response
    */
-  abstract callLLMRaw(
+  /* abstract callLLMRaw(
     messages: DyFM_AI_Message[],
     settings?: DyFM_AI_CallSettings,
     issuer?: string
-  ): Promise<DyFM_AI_LLM_Response>;
+  ): Promise<DyFM_AI_LLM_Response>; */
   
   // Question methods (from OAI_LLM_ServiceBase)
-  abstract askQuestion(set: DyFM_AI_Question_Input): Promise<string>;
-  abstract askYesNoQuestion(set: DyFM_AI_Question_Input): Promise<boolean>;
-  abstract askPercentageQuestion(set: DyFM_AI_Question_Input): Promise<number>;
-  abstract askSelectQuestion(set: DyFM_AI_ListSelect_Input): Promise<string>;
-  abstract requestSelect<T>(set: DyFM_AI_GenericSelect_Input<T>): Promise<T | { unparsableResult: string }>;
-  abstract askMultipleSelectQuestionWithOptions(set: DyFM_AI_MultiSelect_Input): Promise<string[]>;
-  abstract requestMultiselect<T>(set: DyFM_AI_GenericMultiSelect_Input<T>): Promise<T[]>;
-  abstract askJSONQuestionWithKeysDescription(set: DyFM_AI_JSONKeysDescription_Input): Promise<object>;
-  abstract askJSONQuestionWithExactKeys(set: DyFM_AI_JSONExactKeys_Input): Promise<object>;
-  abstract requestJSONWithExactKeys<T>(set: DyFM_AI_JSONExactKeys_Input): Promise<T>;
-  abstract sendMessage(set: DyFM_AI_SimpleMessage_Input): Promise<string>;
+  abstract requestSimpleMessage(set: DyFM_AI_Message_Input<T_AISettings>): Promise<string>;
+  abstract requestYesNo(set: DyFM_AI_Message_Input<T_AISettings>): Promise<boolean>;
+  abstract requestPercentage(set: DyFM_AI_Message_Input<T_AISettings>): Promise<number>;
+
+  /* abstract askSelectQuestion(set: DyFM_AI_ListSelect_Input): Promise<string>; */
+  abstract requestSelect<T>(
+    set: DyFM_AI_GenericSelect_Input<T, T_AISettings>
+  ): Promise<T | { unparsableResult: string }>;
+  /* abstract askMultipleSelectQuestionWithOptions(set: DyFM_AI_MultiSelect_Input): Promise<string[]>; */
+  abstract requestMultiselect<T>(
+    set: DyFM_AI_GenericMultiSelect_Input<T, T_AISettings>
+  ): Promise<T[] | { unparsableResult: string }>;
+
+  abstract requestJSON<T>(set: DyFM_AI_Message_Input<T_AISettings>): Promise<T | { unparsableResult: string }>;
+  abstract requestJSONQuestionWithKeysDescription<T>(
+    set: DyFM_AI_JSONKeysDescription_Input<T_AISettings>
+  ): Promise<T | { unparsableResult: string }>;
+  /* abstract askJSONQuestionWithExactKeys(set: DyFM_AI_JSONExactKeys_Input): Promise<object>; */
+  abstract requestJSONWithExactKeys<T>(
+    set: DyFM_AI_JSONExactKeys_Input<T_AISettings>
+  ): Promise<T | { unparsableResult: string }>;
+  /* abstract sendMessage(set: DyFM_AI_SimpleMessage_Input): Promise<string>; */
+
+  /* abstract requestStringList(set: DyFM_AI_Base_Input<T_AISettings>): Promise<string[] | { unparsableResult: string }>; */
+  abstract requestList<T>(set: DyFM_AI_Message_Input<T_AISettings>): Promise<T[] | { unparsableResult: string }>;
   
   // Helper methods
   /* protected abstract getDefaultErrorSettings(
@@ -75,7 +104,222 @@ export abstract class DyNTS_AI_LLM_ServiceBase extends DyNTS_AI_Provider_Service
     issuer?: string
   ): DyFM_Error_Settings; */
   
-  protected abstract getTextListAsText(list: string[]): string;
+  /* protected abstract getTextListAsText(list: string[]): string; */
   
-  protected abstract logQuestion(set: any): void;
+  /* protected abstract logQuestion(set: DyFM_AI_Base_Input<T_AISettings>): void; */
+
+  protected convertAnswerToBoolean(answer: string): boolean {
+    return answer.toUpperCase().includes(this.predefinedRequests.yesNo.upperCaseYes);
+  }
+
+  protected convertAnswerToNumber(answer: string, message: string): number {
+    if (this.isAnswerValid(answer, message)) {
+      return null;
+    }
+
+    if (isNaN(+answer)) {
+      DyFM_Log.T_error(
+        'DyNTS_AI_LLMChat_ServiceBase.convertAnswerToNumber got an invalid answer', 
+        {
+          question: message,
+          answer: answer,
+        }
+      );
+
+      return null;
+    }
+
+    return +answer;
+  }
+
+  protected convertAnswerToSelectOption<T>(answer: string, message: string, options: T[]): T {
+    if (this.isAnswerValid(answer, message)) {
+      return null;
+    }
+
+    answer = answer.toLocaleUpperCase();
+
+    const stringifiedOptions: string[] = this.stringifySelectOptions(options);
+    for (const stringifiedItem of stringifiedOptions) {
+      if (answer.includes(stringifiedItem.toLocaleUpperCase())) {
+        const parsedItem: T | { unparsableResult: string } = DyFM_Object.safeParseJSON<T>(stringifiedItem);
+
+        if ((parsedItem as { unparsableResult: string }).unparsableResult) {
+          DyFM_Log.T_error(
+            'DyNTS_AI_LLMChat_ServiceBase.convertAnswerToSelectOption got an invalid answer', 
+            {
+              question: message,
+              answer: answer,
+            }
+          );
+
+          return stringifiedItem as T;
+        } else {
+          return parsedItem as T;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  protected convertAnswerToSelectOptions<T>(answer: string, message: string, options: T[]): T[] {
+    if (this.isAnswerValid(answer, message)) {
+      return null;
+    }
+
+    const enrichedOptions: { stringifiedOption: string, parsedOption: T }[] = options.map(
+      (option: T) => ({
+        stringifiedOption: this.stringifySelectOption(option),
+        parsedOption: option
+      })
+    );
+    const result: T[] = [];
+
+    for (const item of enrichedOptions) {
+      if (answer.includes(item.stringifiedOption)) {
+        result.push(item.parsedOption);
+      }
+    }
+
+    return result;
+  }
+
+  protected convertAnswerToJSON<T>(answer: string, message: string): T {
+    if (this.isAnswerValid(answer, message)) {
+      return null;
+    }
+
+    const parsedItem: T | { unparsableResult: string } = DyFM_Object.safeParseJSON<T>(answer);
+    if ((parsedItem as { unparsableResult: string }).unparsableResult) {
+      DyFM_Log.T_error(
+        'DyNTS_AI_LLMChat_ServiceBase.convertAnswerToJSON got an invalid answer', 
+        {
+          question: message,
+          answer: answer,
+        }
+      );
+
+      return null;
+    }
+
+    return parsedItem as T;
+  }
+
+  protected convertAnswerToList<T>(answer: string, message: string): T[] {
+    if (this.isAnswerValid(answer, message)) {
+      return null;
+    }
+
+    return DyFM_Object.safeParseList<T[]>(answer);
+  }
+
+  protected stringifySelectOptions<T>(options: T[]): string[] {
+    return options.map(item => this.stringifySelectOption(item));
+  }
+
+  protected stringifySelectOption<T>(option: T): string {
+    return JSON.stringify(option);
+  }
+
+  protected isAnswerValid(answer: string, message: string): boolean {
+    if (!answer?.trim?.()?.length) {
+      DyFM_Log.T_error(
+        'DyNTS_AI_LLMChat_ServiceBase.convertAnswerToSelectOption got an invalid answer', 
+        {
+          question: message,
+          answer: answer,
+        }
+      );
+
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * olvasható mondatszerű-listaszerű formába teszi a listaelemeket
+   * pl.: ['a', 'b', 'c'] -> '"a", "b" or "c"'
+   */
+  protected getTextListAsText(list: string[]): string {
+    list = list.filter(item => item?.trim()).map(item => `"${item}"`);
+
+    /* list = list.map(item => item.toLocaleLowerCase()); */
+
+    list.push(list.pop() + ' or ' + list.pop());
+
+    return list.join(', ');
+  }
+  
+  protected logQuestion(
+    set: DyFM_AI_Message_Input<T_AISettings>
+  ): void {
+    if (set.settings?.debugLog ?? this._debugLog) {
+      console.log('\n - ', set.message);
+    }
+  }
+
+  protected getDefaultSystemMessage(settings: T_AISettings): DyFM_AI_Message {
+    return {
+      role: DyFM_AI_MessageRole.system,
+      content: settings?.systemPrompt || this.defaultSystemPrompt,
+    };
+  }
+
+  protected validateConversation(conversation: DyFM_AI_Message[]): void {
+    conversation.forEach((message: DyFM_AI_Message, index: number) => {
+      if (!message.role) {
+        throw new DyFM_Error({
+          message: `Message has no role at index ${index}`,
+          additionalContent: {
+            invalidMessage: message,
+            conversation: conversation,
+          }
+        });
+      }
+
+      if (!message.content) {
+        throw new DyFM_Error({
+          message: `Message has no content at index ${index}`,
+          additionalContent: {
+            invalidMessage: message,
+            conversation: conversation,
+          }
+        });
+      }
+    });
+  }
+
+  protected logAnswer(answer: string): void {
+    if (this._debugLog) {
+      console.log(' - answer: ', answer);
+    }
+  }
+
+
+
+  //////////////////////////////////////////////////////////////////////////////////////////
+                                  // LLM CHAT METHODS //
+  //////////////////////////////////////////////////////////////////////////////////////////
+ 
+
+  protected logConversation(
+    set: {
+      conversation: DyFM_AI_Message[], 
+      debugLog?: boolean,
+      /** this is used to readably replace too long contents to eg '...' in logs */
+      replaceThisInLog?: string,
+    }
+  ) {
+    if (set.debugLog || this._debugLog) {
+      DyFM_Log.info('Conversation log at', DyFM_getLocalStackLocation());
+
+      set.conversation.forEach(message => {
+        console.log(
+          ` - ${message.role}: ${message.content.replace(set.replaceThisInLog, this.defaultLogReplacer)}`
+        );
+      });
+    }
+  }
 }

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

@@ -18,7 +18,7 @@ export abstract class DyNTS_AI_Provider_ServiceBase extends DyNTS_SingletonServi
    * Initialize the provider with configuration
    * @param config - Provider-specific configuration
    */
-  abstract initialize(config: DyFM_AI_Config): void;
+  abstract setup(config: DyFM_AI_Config): void;
   
   /**
    * Test the connection to the AI provider

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

@@ -44,12 +44,12 @@ export abstract class DyNTS_Ass_IO_ControlService extends DyNTS_Bot_IO_ControlSe
         });
       
       // Get AI response using EXISTING getAnswerInConversation method
-      const aiResult: string = await this.aiProvider.getAnswerInConversation({
+      const aiResult: string = await this.aiProvider.requestSimpleMessageInConversation({
         conversation: aiMessages,
-        issuer: issuer,
         settings: {
           systemPrompt: this.mainBot_CS.defaultSystemPrompt,
         },
+        issuer: issuer,
       });
       
       // Reply via same provider the message came from

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

@@ -1,25 +1,51 @@
 import { DyNTS_Bot_MessagingProvider_ServiceBase } from '../_services/bot-messaging-provider.service-base';
+import { DyNTS_Bot_MessageWrapper } from './bot-message-wrapper.interface';
 
 /**
  * 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
+export class DyNTS_Bot_ChannelWrapper<
+  T_MessagingPlatformChannel extends any = any,
+  T_MessagingPlatformMessage 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>, 
+    T_MessagingPlatformMessage, //DyNTS_Bot_MessageWrapper<any>, 
     any, //DyNTS_Bot_UserWrapper<any>, 
     any
   >;
+
+  constructor(
+    set: Partial<DyNTS_Bot_ChannelWrapper<T_MessagingPlatformChannel, T_MessagingPlatformMessage>>
+  ) {
+    Object.assign(this, set);
+  }
+
+  async sendMessage(content: string, issuer: string): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>> {
+    return await this.provider.sendMessageToChannel(this, content, issuer);
+  }
+
+  async sendTyping(): Promise<void> {
+    await this.provider.sendTyping(this);
+  }
+
+  async fetchMessages(limit: number): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>[]> {
+    return await this.provider.fetchMessages(this, limit);
+  }
+
+  /* async fetchAllMessagesWi */
+
+  async clear(): Promise<void> {
+    await this.provider.clearChannel(this);
+  }
 }
 

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

@@ -5,7 +5,7 @@ import { DyNTS_Bot_MessagingProvider_ServiceBase } from '../_services/bot-messag
  * This ensures messages include the provider information needed to send replies
  * back through the correct platform
  */
-export interface DyNTS_Bot_MessageWrapper<
+export class DyNTS_Bot_MessageWrapper<
   T_MessagingPlatformMessage extends any = any,
 > {
   id: string;
@@ -20,7 +20,7 @@ export interface DyNTS_Bot_MessageWrapper<
   replyToMessageId?: string;
   mentions: string[]; // user IDs
   issuer: string;
-  
+
   rawPlatformMessage: T_MessagingPlatformMessage; // Original platform message for platform-specific operations
   
   /** Reference to the provider instance for sending replies */
@@ -30,5 +30,27 @@ export interface DyNTS_Bot_MessageWrapper<
     any, //DyNTS_Bot_ChannelWrapper<any>,
     any //DyNTS_Bot_UserWrapper<any>
   >;
+
+  constructor(
+    set: Partial<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>
+  ) {
+    Object.assign(this, set);
+  }
+
+  async reply(content: string): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>> {
+    return await this.provider.replyToMessage(this, content);
+  }
+
+  async sendTyping(): Promise<void> {
+    await this.provider.sendTypingForMessage(this);
+  }
+
+  async fetchMessages(limit: number): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>[]> {
+    return await this.provider.fetchMessagesForMessage(this, limit);
+  }
+
+  async delete(): Promise<void> {
+    await this.provider.deleteMessage(this);
+  }
 }
 

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

@@ -4,7 +4,7 @@ import { DyNTS_Bot_MessagingProvider_ServiceBase } from '../_services/bot-messag
  * Wraps a bot user with provider context
  * This ensures users include the provider information needed for platform-specific operations
  */
-export interface DyNTS_Bot_UserWrapper<
+export class DyNTS_Bot_UserWrapper<
   T_MessagingPlatformUser extends any = any,
   /* T_MessagingPlatformService extends DyNTS_Bot_MessagingProvider_ServiceBase<
     any, //DyNTS_Bot_ChannelWrapper<any> , 
@@ -23,7 +23,7 @@ export interface DyNTS_Bot_UserWrapper<
   username: string;
   displayName: string;
   isBot: boolean;
-  
+
   rawPlatformUser: T_MessagingPlatformUser;
   
   /** Reference to the provider instance for platform-specific operations */
@@ -32,5 +32,11 @@ export interface DyNTS_Bot_UserWrapper<
     any, //DyNTS_Bot_MessageWrapper<any> , 
     T_MessagingPlatformUser
   >;
+
+  constructor(
+    set: Partial<DyNTS_Bot_UserWrapper<T_MessagingPlatformUser>>
+  ) {
+    Object.assign(this, set);
+  }
 }
 

package/src/_modules/bot/_modules/discord-bot/_services/dib-messaging-provider.control-service.ts

@@ -486,7 +486,7 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
   }
 
   wrapMessage(message: Message): DyNTS_DiB_Message {
-    return {
+    return new DyNTS_Bot_MessageWrapper<Message>({
       id: message.id,
       content: message.content,
       authorId: message.author.id,
@@ -503,11 +503,11 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
       issuer: message.author.id,
 
       provider: this,
-    };
+    });
   }
 
   wrapChannel(channel: Channel): DyNTS_DiB_Channel {
-    return {
+    return new DyNTS_Bot_ChannelWrapper<Channel>({
       id: channel.id,
       name: (channel as TextChannel).name || ('DM Channel with ' + (channel as DMChannel).recipient.username),
       isTextBased: channel.isTextBased(),
@@ -515,11 +515,11 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
       rawPlatformChannel: channel,
 
       provider: this,
-    };
+    });
   }
 
   wrapUser(user: GuildMember): DyNTS_DiB_User {
-    return {
+    return new DyNTS_Bot_UserWrapper<GuildMember>({
       id: user.user.id,
       username: user.user.username,
       displayName: user.displayName,
@@ -527,6 +527,6 @@ export class DyNTS_DiB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
       rawPlatformUser: user,
       
       provider: this,
-    };
+    });
   }
 }

package/src/_modules/bot/_modules/dynamo-bot/_services/dyb-messaging-provider.control-service.ts

@@ -386,7 +386,7 @@ export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
   }
 
   wrapMessage(msgMessage: any): DyNTS_Bot_MessageWrapper<DyFM_Msg_Message> {
-    return {
+    return new DyNTS_Bot_MessageWrapper<DyFM_Msg_Message>({
       id: msgMessage._id || msgMessage.id,
       content: msgMessage.content || '',
       authorId: msgMessage.senderId || msgMessage.authorId,
@@ -403,28 +403,28 @@ export class DyNTS_DyB_MessagingProvider_ControlService extends DyNTS_Bot_Messag
       issuer: msgMessage.issuer || 'unknown',
 
       provider: this,
-    };
+    });
   }
 
   wrapChannel(conversation: any): DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation> {
-    return {
+    return new DyNTS_Bot_ChannelWrapper<DyFM_Msg_Conversation>({
       id: conversation._id || conversation.id,
       name: conversation.name || conversation.platformChannelId || 'unknown',
       isTextBased: true,
       isDM: conversation.type === 'direct',
       rawPlatformChannel: conversation,
       provider: this
-    };
+    });
   }
 
   wrapUser(user: any): DyNTS_Bot_UserWrapper<DyFM_Msg_Participant> {
-    return {
+    return new DyNTS_Bot_UserWrapper<DyFM_Msg_Participant>({
       id: user.userId || user.id,
       username: user.username || user.userId || user.id,
       displayName: user.displayName || user.username || user.userId,
       isBot: user.isBot || false,
       rawPlatformUser: user,
       provider: this
-    };
+    });
   }
 }