@futdevpro/nts-dynamo 1.14.35 → 1.14.36

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/discord-assistant/_services/dias-chunk.data-service.ts

@@ -61,9 +61,9 @@ export abstract class DyNTS_DiAs_Chunk_DataService<
     try {
       DyFM_Log.info('🔍 Document message received:', conversation[conversation.length - 1].content);
 
-      const vectorSearchNeeded: boolean = await this.llmChat_CS.yesNoQuestionInConversation({
+      const vectorSearchNeeded: boolean = await this.llmChat_CS.requestYesNoInConversation({
         conversation: conversation,
-        question: DyNTS_OAI_LLMDefaultPredefined_Requests.vectorSearch.doWeNeedVectorSearch,
+        message: DyNTS_OAI_LLMDefaultPredefined_Requests.vectorSearch.doWeNeedVectorSearch,
         issuer: this.issuer,
         settings: {
           systemPrompt: DyNTS_OAI_LLMDefaultPredefined_Requests.defaultSystemPrompt,
@@ -74,12 +74,12 @@ export abstract class DyNTS_DiAs_Chunk_DataService<
       if (vectorSearchNeeded) {
         result = await this.vectorSearchAndResolveConversation(conversation, limit, numberOfCandidates);
       } else {
-        result = await this.llmChat_CS.resolveConversationMessage({
+        result = await this.llmChat_CS.requestSimpleMessageInConversation({
           conversation: conversation,
-          issuer: this.issuer,
           settings: {
             systemPrompt: DyNTS_OAI_LLMDefaultPredefined_Requests.defaultSystemPrompt,
           },
+          issuer: this.issuer,
         });
       }
 
@@ -117,15 +117,15 @@ export abstract class DyNTS_DiAs_Chunk_DataService<
 
       DyFM_Log.H_success(`✅ Document search results:`, parsedSearchResults);
       
-      const result: string = await this.llmChat_CS.resolveConversationMessage({
+      const result: string = await this.llmChat_CS.requestSimpleMessageInConversation({
         conversation: conversation,
-        issuer: this.issuer,
         settings: {
           systemPrompt: 
             DyNTS_OAI_LLMDefaultPredefined_Requests.defaultSystemPrompt +
             DyNTS_OAI_LLMDefaultPredefined_Requests.vectorSearch.resolveSearchResults +
             parsedSearchResults,
         },
+        issuer: this.issuer,
       });
 
       return result;
@@ -146,15 +146,15 @@ export abstract class DyNTS_DiAs_Chunk_DataService<
     try {
       const lastMessage: DyFM_AI_Message = conversation[conversation.length - 1];
 
-      const searchQuestion: string = await this.llmChat_CS.getAnswerInConversation({
+      const searchQuestion: string = await this.llmChat_CS.requestSimpleMessageInConversation({
         conversation: conversation,
-        newMessage: DyNTS_OAI_LLMDefaultPredefined_Requests.vectorSearch.getSearchQuestion,
-        issuer: this.issuer,
+        message: DyNTS_OAI_LLMDefaultPredefined_Requests.vectorSearch.getSearchQuestion,
         settings: {
           systemPrompt: 
             DyNTS_OAI_LLMDefaultPredefined_Requests.defaultSystemPrompt +
             DyNTS_OAI_LLMDefaultPredefined_Requests.vectorSearch.systemPrompt,
         },
+        issuer: this.issuer,
       });
 
       DyFM_Log.testInfo('🔍 Document search question:', searchQuestion);

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

@@ -39,12 +39,12 @@ export abstract class DyNTS_DiAs_IO_ControlService extends DyNTS_DiBo_IO_Control
           issuer: issuer,
         });
 
-      const gptResult: string = await this.llmChat_CS.resolveConversationMessage({
+      const gptResult: string = await this.llmChat_CS.requestSimpleMessageInConversation({
         conversation: oaiMessages,
-        issuer: issuer,
         settings: { 
           systemPrompt: this.mainDiscordBot_CS.defaultSystemPrompt,
         },
+        issuer: issuer,
       });
 
       return await message.reply(gptResult);