@futdevpro/nts-dynamo 1.10.77 → 1.11.2

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

@@ -0,0 +1,621 @@
+import { OpenAI } from 'openai';
+
+import { DyFM_OpenAI_Settings, DyFM_OpenAIModel, DyFM_GPTCall_Settings } from '@futdevpro/fsm-dynamo/open-ai';
+import { DyFM_AnyError, DyFM_clone, DyFM_Error, DyFM_Error_Settings, DyFM_Log, DyFM_notNull } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_OAI_GPT_Message } from '../_models/interfaces/oai-gpt-message.interface';
+import { ChatCompletion } from 'openai/resources';
+import { ChatCompletionCreateParamsBase, ChatCompletionMessageParam } from 'openai/resources/chat/completions';
+import { DyNTS_OAI_GPT_Message_Role } from '../_enums/oai-gpt-message-role.enum';
+import { DyNTS_OAI_LLM_Predefined_Requests } from '../_models/interfaces/oai-llm-predefined-requests.interface';
+import { DyFM_safeParseJSON, DyFM_safeParseList, DyNTS_OAI_LLM_ServiceBase } from './oai-llm.service-base';
+import { DyNTS_OAI_global_settings } from '../_collections/oai-global-settings.const';
+
+
+/**
+ * {
+ *   organization: 'org-XY',
+ *   apiKey: 'sk-XY',
+ *   project: 'proj_XY',
+ * }
+ */
+
+// Di Dictionary DiModel DiEz DiAz
+
+export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
+  
+  /**
+   * Asks the AI to answer a yes/no question
+   * 
+   * Uses the {@link DyNTS_OAI_LLM_Predefined_Requests.yesNo.request} to ask the question,
+   * and the {@link DyNTS_OAI_LLM_Predefined_Requests.yesNo.upperCaseYes} to check the answer
+   */
+  async yesNoQuestionInConversation(
+    conversation: DyNTS_OAI_GPT_Message[],
+    question: string, 
+    issuer: string,
+    debugLog?: boolean,
+    settings?: DyFM_GPTCall_Settings,
+    /** this is used to readably replace too long contents to eg '...' in logs */
+    replaceThisInLog?: string
+  ): Promise<boolean> {
+    question += this.predefinedRequests.yesNo.request;
+
+    this.logQuestion(question, replaceThisInLog, debugLog);
+
+    const answer = await this.getAnswerInConversation(
+      conversation, 
+      question, 
+      issuer, 
+      settings,
+      debugLog,
+      replaceThisInLog
+    );
+
+    return answer.toUpperCase().includes(this.predefinedRequests.yesNo.upperCaseYes);
+  }
+  askYesNoQuestionInConversation = this.yesNoQuestionInConversation;
+
+  /**
+   * Asks the AI to answer a simple question
+   * 
+   * Uses the {@link DyNTS_OAI_LLM_Predefined_Requests.simpleQuestion} to ask the question
+   */
+  async simpleQuestionInConversation(
+    conversation: DyNTS_OAI_GPT_Message[],
+    question: string, 
+    issuer: string,
+    settings?: DyFM_GPTCall_Settings,
+    debugLog?: boolean,
+    /** this is used to readably replace too long contents to eg '...' in logs */
+    replaceThisInLog?: string
+  ): Promise<string> {
+    this.logQuestion(question, replaceThisInLog, debugLog);
+
+    return await this.getAnswerInConversation(
+      conversation, 
+      question, 
+      issuer, 
+      settings,
+      debugLog,
+      replaceThisInLog
+    );
+  }
+  askSimpleQuestionInConversation = this.simpleQuestionInConversation;
+
+  /**
+   * Asks the AI to answer a percentage question
+   * 
+   * Uses the {@link DyNTS_OAI_LLM_Predefined_Requests.percentageOnly} to ask the question
+   */
+  async percentageQuestionInConversation(
+    conversation: DyNTS_OAI_GPT_Message[],
+    question: string, 
+    issuer: string,
+    settings?: DyFM_GPTCall_Settings,
+    debugLog?: boolean,
+    /** this is used to readably replace too long contents to eg '...' in logs */
+    replaceThisInLog?: string
+  ): Promise<number> {
+    question += this.predefinedRequests.percentageOnly;
+
+    this.logQuestion(question, replaceThisInLog, debugLog);
+
+    const answer = await this.getAnswerInConversation(
+      conversation, 
+      question, 
+      issuer, 
+      settings,
+      debugLog,
+      replaceThisInLog
+    );
+
+    if (isNaN(+answer)) {
+      DyFM_Log.error('GPT_ServiceBase', 'asykPercentageQuestion', 'Invalid answer', {
+        question,
+        answer,
+      });
+
+      return null;
+    }
+
+    return +answer;
+  }
+  askPercentageQuestionInConversation = this.percentageQuestionInConversation;
+  
+
+  /**
+   * Asks the AI to select one of the options from the list
+   * 
+   * Uses the {@link DyNTS_OAI_LLM_Predefined_Requests.selectRequest} to ask the question
+   */
+  async selectQuestionInConversation(
+    conversation: DyNTS_OAI_GPT_Message[],
+    question: string, 
+    selectFrom: string[], 
+    issuer: string,
+    settings?: DyFM_GPTCall_Settings,
+    debugLog?: boolean,
+    /** this is used to readably replace too long contents to eg '...' in logs */
+    replaceThisInLog?: string
+  ): Promise<string> {
+    // replace the {{DyNTS_selectOptions}} with the list of options
+    const selectQuestionAddition = this.predefinedRequests.selectRequest.replace(
+      '{{DyNTS_selectOptions}}', 
+      this.getTextListAsText(selectFrom)
+    );
+    question += selectQuestionAddition;
+    
+    this.logQuestion(question, replaceThisInLog, debugLog);
+
+    let answer = await this.getAnswerInConversation(
+      conversation, 
+      question, 
+      issuer, 
+      settings,
+      debugLog,
+      replaceThisInLog
+    );
+    
+    answer = answer.toLocaleUpperCase();
+    
+    for (const item of selectFrom) {
+      if (answer.includes(item.toLocaleUpperCase())) return item;
+    }
+
+    return null;
+  }
+  askSelectQuestionInConversation = this.selectQuestionInConversation;
+
+  /**
+   * Asks the AI to select one of the options from the list
+   * Similar to {@link askSelectQuestion}, 
+   * but with a more generic approach that can be used for objects
+   * 
+   * Uses the {@link DyNTS_OAI_LLM_Predefined_Requests.selectRequest} to ask the question
+   */
+  async requestSelectInConversation<T>(
+    conversation: DyNTS_OAI_GPT_Message[],
+    question: string,
+    selectFrom: T[],
+    issuer: string,
+    settings?: DyFM_GPTCall_Settings,
+    debugLog?: boolean,
+    /** this is used to readably replace too long contents to eg '...' in logs */
+    replaceThisInLog?: string,
+  ): Promise<T | { unparsableResult: string }> {
+    const selectQuestionAddition = this.predefinedRequests.selectRequest.replace(
+      '{{DyNTS_selectOptions}}', 
+      this.getTextListAsText(selectFrom.map(item => `"${JSON.stringify(item)}"`))
+    );
+    question += selectQuestionAddition;
+
+    this.logQuestion(question, null, debugLog); 
+
+    const answer = await this.getAnswerInConversation(
+      conversation, 
+      question, 
+      issuer, 
+      settings,
+      debugLog,
+      replaceThisInLog
+    );
+
+    return DyFM_safeParseJSON<T>(answer);
+  }
+  askRequestSelectInConversation = this.requestSelectInConversation;
+
+  /**
+   * Asks the AI to select one or more of the options from the list
+   * 
+   * Uses the {@link DyNTS_OAI_LLM_Predefined_Requests.multiselect} to ask the question
+   */
+  async multipleSelectQuestionWithOptionsInConversation(
+    conversation: DyNTS_OAI_GPT_Message[],
+    question: string, 
+    options: string[], 
+    issuer: string,
+    settings?: DyFM_GPTCall_Settings,
+    debugLog?: boolean,
+    /** this is used to readably replace too long contents to eg '...' in logs */
+    replaceThisInLog?: string
+  ): Promise<string[]> {
+    const selectQuestionAddition = this.predefinedRequests.multiselect.replace(
+      '{{DyNTS_selectOptions}}', 
+      this.getTextListAsText(options)
+    );
+    question += selectQuestionAddition;
+
+    let answer = await this.getAnswerInConversation(
+      conversation, 
+      question, 
+      issuer, 
+      settings,
+      debugLog,
+      replaceThisInLog
+    );
+    
+    answer = answer.toLocaleUpperCase();
+    
+    const result: string[] = [];
+
+    for (const item of options) {
+      if (answer.includes(item.toLocaleUpperCase())) {
+        result.push(item);
+      }
+    }
+
+    return result;
+  }
+  askMultipleSelectQuestionWithOptionsInConversation = this.multipleSelectQuestionWithOptionsInConversation;
+
+  /**
+   * Asks the AI to select one or more of the options from the list
+   * Similar to {@link askMultipleSelectQuestionWithOptions}, 
+   * but with a more generic approach that can be used for objects
+   * 
+   * Uses the {@link DyNTS_OAI_LLM_Predefined_Requests.multiselect} to ask the question
+   */
+  async requestMultipleSelectInConversation<T>(
+    conversation: DyNTS_OAI_GPT_Message[],
+    question: string,
+    options: T[],
+    issuer: string,
+    settings?: DyFM_GPTCall_Settings,
+    debugLog?: boolean,
+    /** this is used to readably replace too long contents to eg '...' in logs */
+    replaceThisInLog?: string,
+  ): Promise<T[]> {
+    const selectQuestionAddition = this.predefinedRequests.multiselect.replace(
+      '{{DyNTS_selectOptions}}', 
+      this.getTextListAsText(options.map(item => `"${JSON.stringify(item)}"`))
+    );
+    question += selectQuestionAddition;
+    
+    this.logQuestion(question, null, debugLog);
+
+    const answer = await this.getAnswerInConversation(
+      conversation, 
+      question, 
+      issuer, 
+      settings,
+      debugLog,
+      replaceThisInLog
+    );
+
+    return DyFM_safeParseList<T[]>(answer);
+  }
+  askRequestMultipleSelectInConversation = this.requestMultipleSelectInConversation;
+
+  /**
+   * Asks the AI to answer a question that must result a JSON object
+   * 
+   * If the answer is not a valid JSON object, it will return { unparsableResult: answer }
+   * 
+   * Uses the {@link DyNTS_OAI_LLM_Predefined_Requests.jsonRequest} to ask the question
+   * 
+   * (uses {@link DyFM_safeParseJSON})
+   */
+  async jsonQuestionInConversation<T = any>(
+    conversation: DyNTS_OAI_GPT_Message[],
+    question: string, 
+    issuer: string,
+    settings?: DyFM_GPTCall_Settings,
+    debugLog?: boolean,
+    /** this is used to readably replace too long contents to eg '...' in logs */
+    replaceThisInLog?: string
+  ): Promise<T | { unparsableResult: string }> {
+    question += this.predefinedRequests.jsonRequest;
+
+    this.logQuestion(question, replaceThisInLog, debugLog);
+
+    const answer = await this.getAnswerInConversation(
+      conversation, 
+      question, 
+      issuer, 
+      settings,
+      debugLog,
+      replaceThisInLog
+    );
+    
+    return DyFM_safeParseJSON<T>(answer);
+  }
+  askJsonQuestionInConversation = 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 jsonQuestionWithKeysDescriptionInConversation<T = any>(
+    conversation: DyNTS_OAI_GPT_Message[],
+    question: string, 
+    keysDescription: string,
+    issuer: string,
+    settings?: DyFM_GPTCall_Settings,
+    debugLog?: boolean,
+    /** this is used to readably replace too long contents to eg '...' in logs */
+    replaceThisInLog?: string
+  ): Promise<T | { unparsableResult: string }> {
+    const jsonRequestWithKeysDescription = this.predefinedRequests.jsonRequestWithKeysDescription.replace(
+      '{{DyNTS_jsonKeysDescription}}', 
+      keysDescription
+    );
+    question += jsonRequestWithKeysDescription;
+
+    this.logQuestion(question, replaceThisInLog, debugLog);
+
+    const answer = await this.getAnswerInConversation(
+      conversation, 
+      question, 
+      issuer, 
+      settings,
+      debugLog,
+      replaceThisInLog
+    );
+
+    return DyFM_safeParseJSON<T>(answer);
+  }
+  askJsonQuestionWithKeysDescriptionInConversation = 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 jsonQuestionWithExactKeysInConversation<T = any>(
+    conversation: DyNTS_OAI_GPT_Message[],
+    question: string, 
+    keys: string[],
+    issuer: string,
+    settings?: DyFM_GPTCall_Settings,
+    debugLog?: boolean,
+    /** this is used to readably replace too long contents to eg '...' in logs */
+    replaceThisInLog?: string
+  ): Promise<T | { unparsableResult: string }> {
+    const jsonRequestWithExactKeys = this.predefinedRequests.jsonRequestWithExactKeys.replace(
+      '{{DyNTS_jsonKeys}}', 
+      this.getTextListAsText(keys)
+    );
+    question += jsonRequestWithExactKeys;
+
+    this.logQuestion(question, replaceThisInLog, debugLog);
+
+    const answer = await this.getAnswerInConversation(
+      conversation, 
+      question, 
+      issuer, 
+      settings,
+      debugLog,
+      replaceThisInLog
+    );
+
+    return DyFM_safeParseJSON<T>(answer);
+  }
+  askJsonQuestionWithExactKeysInConversation = this.jsonQuestionWithExactKeysInConversation;
+
+  /**
+   * Asks the AI to answer a question that must result a list of strings
+   * 
+   * If the answer is not a valid JSON list, it will return the answer as a single item in an array
+   * 
+   * Uses the {@link DyNTS_OAI_LLM_Predefined_Requests.listRequest} to ask the question
+   * 
+   * (uses {@link DyFM_safeParseList})
+   */
+  async listQuestionInConversation(
+    conversation: DyNTS_OAI_GPT_Message[],
+    question: string, 
+    issuer: string,
+    settings?: DyFM_GPTCall_Settings,
+    debugLog?: boolean,
+    /** this is used to readably replace too long contents to eg '...' in logs */
+    replaceThisInLog?: string,
+  ): Promise<string[]> {
+    question += this.predefinedRequests.listRequest;
+
+    this.logQuestion(question, replaceThisInLog, debugLog);
+
+    const answer = await this.getAnswerInConversation(
+      conversation, 
+      question, 
+      issuer, 
+      settings,
+      debugLog,
+      replaceThisInLog
+    );
+
+    return DyFM_safeParseList(answer);
+  }
+  askListQuestionInConversation = this.listQuestionInConversation;
+
+  /**
+   * Asks the AI to answer a question
+   * 
+   * Uses the {@link resolveSimpleUserMessage}
+   */
+  /* async getQuestionAnswerInConversation(
+    conversation: DyNTS_OAI_GPT_Message[],
+    question: string, 
+    issuer: string,
+    debugLog?: boolean,
+    messageSettings: DyFM_GPTCall_Settings = this.defaultSettings
+  ): Promise<string> {
+    const answer = await this.resolveSimpleUserMessageInConversation(
+      conversation, 
+      question, 
+      issuer, 
+      messageSettings,
+    ) as Promise<string>;
+
+    if (debugLog) {
+      console.log(' - ', answer);
+    }
+
+    return answer;
+  } */
+  
+  /**
+   * Asks the AI to answer a question using the whole conversation
+   * (If you want to use only the conversation, without adding a new message, 
+   * use directly the {@link resolveConversation})
+   * 
+   * Uses the {@link resolveConversation}
+   */
+  async getAnswerInConversation(
+    conversation: DyNTS_OAI_GPT_Message[],
+    newMessage: string, 
+    issuer: string,
+    settings?: DyFM_GPTCall_Settings,
+    debugLog?: boolean,
+    /** this is used to readably replace too long contents to eg '...' in logs */
+    replaceThisInLog?: string,
+  ): Promise<string> {
+    conversation.push({
+      role: DyNTS_OAI_GPT_Message_Role.user,
+      content: newMessage,
+    });
+
+    const answer: string = (await this.resolveConversation(
+      conversation, 
+      issuer, 
+      settings,
+      false,
+      debugLog,
+      replaceThisInLog,
+    )) as string;
+
+    if (debugLog || this.debugLog) {
+      console.log(' - answer: ', answer);
+    }
+
+    return answer;
+  }
+  getQuestionAnswerInConversation = this.getAnswerInConversation;
+  getQuestionInConversation = this.getAnswerInConversation;
+  askQuestionInConversation = this.getAnswerInConversation;
+
+  /**
+   * Resolves a conversation
+   * 
+   * Uses the {@link getMessageCreateInput}
+   */
+  async resolveConversation(
+    conversation: DyNTS_OAI_GPT_Message[],
+    issuer: string,
+    settings?: DyFM_GPTCall_Settings,
+    getFullResponse?: boolean,
+    debugLog?: boolean,
+    /** this is used to readably replace too long contents to eg '...' in logs */
+    replaceThisInLog?: string,
+  ): Promise<string | ChatCompletion> {
+    try {
+      conversation.unshift(this.getDefaultSystemMessage(settings));
+
+      // conversation shortening
+      const shortenedConversation = this.shortenConversation(conversation, issuer, debugLog);
+      
+      this.logConversation(shortenedConversation, debugLog, replaceThisInLog);
+
+      const result: ChatCompletion = await this.openai.chat.completions.create(
+        this.getMessageCreateInput(shortenedConversation, issuer, settings)
+      ) as ChatCompletion;
+
+      if (getFullResponse) {
+        return result;
+      }
+
+      return result.choices[0].message.content;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('resolveConversation', error, issuer),
+        
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-OAB-RC0`,
+      });
+    }
+  }
+  resolveSimpleUserMessageInConversation = this.resolveConversation;
+
+  protected shortenConversation(
+    conversation: DyNTS_OAI_GPT_Message[],
+    issuer: string,
+    debugLog?: boolean,
+  ): DyNTS_OAI_GPT_Message[] {
+    try {
+      const clonedConversation = DyFM_clone(conversation);
+      const systemMessages = clonedConversation.filter(
+        message => message.role === DyNTS_OAI_GPT_Message_Role.system
+      );
+      const systemMessagesStringLength = JSON.stringify(systemMessages).length;
+      const msgs: string[] = clonedConversation.filter(
+        message => message.role !== DyNTS_OAI_GPT_Message_Role.system
+      ).map(message => message.content);
+      let stringifiedMessages = JSON.stringify(msgs);
+
+      if (this.debugLog || debugLog) {
+        console.log('stringifiedMessagesCount before removing', stringifiedMessages.length);
+      }
+      
+      let removedMessagesCount = 0;
+      let lastStringifiedMessagesLength = stringifiedMessages.length;
+
+      while (
+        (stringifiedMessages.length + systemMessagesStringLength) > DyNTS_OAI_global_settings.maxMessagesStringLength &&
+        clonedConversation.length > 1
+      ) {
+        clonedConversation.splice(0, 1);
+        msgs.splice(0, 1);
+        removedMessagesCount++;
+        stringifiedMessages = JSON.stringify(msgs);
+        lastStringifiedMessagesLength = stringifiedMessages.length;
+      }
+
+      if (this.debugLog || debugLog) {
+        console.log('removedMessagesCount', removedMessagesCount);
+        console.log('lastStringifiedMessagesLength', lastStringifiedMessagesLength);
+      }
+  
+      if (!clonedConversation.length) {
+        DyFM_Log.error('No conversation messages (left)', { 
+          /* conversation: DyFM_clone(conversation), */
+          conversationLength: conversation.length,
+          clonedConversation: DyFM_clone(clonedConversation),
+        });
+        throw new Error('No conversation messages (left)');
+      }
+
+      return [ ...systemMessages, ...clonedConversation ];
+    } catch (error) {
+      console.error('❌❌ Error shortening conversation:', error);
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('shortenConversation', error, issuer),
+        
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-OAB-SC0`,
+      });
+    } 
+  }
+
+  protected logConversation(
+    conversation: DyNTS_OAI_GPT_Message[], 
+    debugLog?: boolean,
+    /** this is used to readably replace too long contents to eg '...' in logs */
+    replaceThisInLog?: string,
+  ) {
+    if (debugLog || this.debugLog) {
+      conversation.forEach(message => {
+        console.log(
+          ` - ${message.role}: ${message.content.replace(replaceThisInLog, this.defaultLogReplacer)}`
+        );
+      });
+    }
+  }
+}