@futdevpro/nts-dynamo 1.10.22 → 1.10.24

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

@@ -0,0 +1,440 @@
+
+import { OpenAI, ClientOptions } from 'openai';
+import { ChatCompletion, ChatCompletionMessageParam } from 'openai/resources';
+
+import { DyFM_AnyError, DyFM_Error, DyFM_Error_Settings, DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_OpenAIModel } from '../_enums/open-ai-model.enum';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_OpenAI_ServiceBase } from './open-ai.service-base';
+import { DyNTS_GPTCall_Settings } from '../_models/gpt-call-settings.interface';
+import { RequestOptions } from 'openai/core';
+import { ChatCompletionCreateParamsBase } from 'openai/resources/chat/completions';
+
+/**
+ * {
+    organization: 'org-XY',
+    apiKey: 'sk-XY',
+    project: 'proj_XY',
+  }
+ */
+
+// Di Dictionary DiModel DiEz DiAz
+
+export class DyNTS_GPT_ServiceBase extends DyNTS_OpenAI_ServiceBase {
+
+  defaultLogReplacer: string = '...';
+  
+  async askYesNoQuestion(
+    question: string, 
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<boolean> {
+    question += ' (Only answer with "Yes" or "No")';
+
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    const answer = await this.getQuestionAnswer(question, issuer);
+
+    return answer.toUpperCase().includes('YES');
+  }
+
+  async askSimpleQuestion(
+    question: string, 
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<string> {
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    return await this.getQuestionAnswer(question, issuer);
+  }
+
+  async askPercentageQuestion(
+    question: string, 
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<number> {
+    question += ' (Only answer with a number between 0 and 1, e.g.: 0.65)';
+
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    const answer = await this.getQuestionAnswer(question, issuer);
+
+    if (isNaN(+answer)) {
+      DyFM_Log.error('GPT_ServiceBase', 'asykPercentageQuestion', 'Invalid answer', {
+        question,
+        answer,
+      });
+
+      return null;
+    }
+
+    return +answer;
+  }
+
+  async askSelectQuestion(
+    question: string, 
+    selectFrom: string[], 
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<string> {
+    question += ` (Only answer with one of the following: ${this.getListAsText(selectFrom)})`;
+    
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    let answer = await this.getQuestionAnswer(question, issuer);
+    
+    answer = answer.toLocaleUpperCase();
+    
+    for (const item of selectFrom) {
+      if (answer.includes(item.toLocaleUpperCase())) return item;
+    }
+
+    return null;
+  }
+
+  async askMultipleSelectQuestionWithOptions(
+    question: string, 
+    options: string[], 
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<string[]> {
+    question += (` (You can choose one or more of the following: ${this.getListAsText(options)})`);
+    
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    let answer = await this.getQuestionAnswer(question, issuer);
+    
+    answer = answer.toLocaleUpperCase();
+    
+    const result: string[] = [];
+
+    for (const item of options) {
+      if (answer.includes(item.toLocaleUpperCase())) {
+        result.push(item);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Azt kérjük tőle, hogy adjon egy JSON formában választ.
+   * Amit aztán megpróbálunk JSON.parse-olni.
+   * Ha nem sikerül, akkor { unparsable: answer }-t adunk vissza.
+   */
+  async askJSONQuestion(
+    question: string, 
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<any> {
+    question += ' (The answer must be in JSON format)';
+
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    const answer = await this.getQuestionAnswer(question, issuer);
+    
+    try {
+      // replace all ```json, ```, \n
+      return JSON.parse(
+        answer.replaceAll('```json', '').replaceAll('```', '').replaceAll('\n', '')
+      );
+    } catch (error) {
+      return {
+        unparsable: answer,
+      };
+    }
+  }
+
+  /**
+   * Azt kérjük tőle, hogy adjon egy JSON formában választ.
+   * Amit aztán megpróbálunk JSON.parse-olni.
+   * Ha nem sikerül, akkor { unparsable: answer }-t adunk vissza.
+   * 
+   * A keysDescription-be leírjuk, milyen kulcsokat várunk. (nem konkrét kulcsneveket)
+   */
+  async askJSONQuestionWithKeysDescription(
+    question: string, 
+    keysDescription: string,
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<any> {
+    question += ` (The answer must be in JSON format, ${keysDescription})`;
+
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    const answer = await this.getQuestionAnswer(question, issuer);
+
+    try {
+      // replace all ```json, ```, \n
+      return JSON.parse(
+        answer.replaceAll('```json', '').replaceAll('```', '').replaceAll('\n', '')
+      );
+    } catch (error) {
+      return {
+        unparsable: answer,
+      };
+    }
+  }
+
+  /**
+   * Azt kérjük tőle, hogy adjon egy JSON formában választ.
+   * Amit aztán megpróbálunk JSON.parse-olni.
+   * Ha nem sikerül, akkor { unparsable: answer }-t adunk vissza.
+   * 
+   * A keys-be leírjuk a konkrét kulcsneveket.
+   */
+  async askJSONQuestionWithExactKeys(
+    question: string, 
+    keys: string[],
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<any> {
+    question += ` (The answer must be in JSON format, ` +
+      `where the keys are: ${this.getListAsText(keys)})`;
+
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    const answer = await this.getQuestionAnswer(question, issuer);
+
+    try {
+      // replace all ```json, ```, \n
+      return JSON.parse(
+        answer.replaceAll('```json', '').replaceAll('```', '').replaceAll('\n', '')
+      );
+    } catch (error) {
+      return {
+        unparsable: answer,
+      };
+    }
+  }
+
+  async askListQuestion(
+    question: string, 
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<string[]> {
+    question += ' (The answer must be in JSON format, a list of strings)';
+
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    const answer = await this.getQuestionAnswer(question, issuer);
+
+    try {
+      const parsed = JSON.parse(
+        answer.replaceAll('```json', '').replaceAll('```', '').replaceAll('\n', '')
+      );
+
+      if (Array.isArray(parsed)) {
+        return parsed;
+      } else if (typeof parsed === 'object') {
+        return Object.values(parsed);
+      } else {
+        DyFM_Log.error('GPT_ServiceBase', 'askListQuestion', 'Invalid answer', {
+          question,
+          answer,
+        });
+
+        return [ parsed ];
+      }
+    } catch (error) {
+      return answer.split('\n').filter(item => item);
+    }
+  }
+
+  private logQuestion(question: string, issuer: string, replaceThisInLog?: string): void {
+    if (this.debugLog) {
+      if (replaceThisInLog) {
+        question = question.replace(replaceThisInLog, this.defaultLogReplacer);
+      }
+
+      console.log('\n - ', question);
+    }
+  }
+
+  /**
+   * This function will log the answer if the debugLog is true
+   */
+  async getQuestionAnswer(
+    question: string, 
+    issuer: string,
+    messageSettings: DyNTS_GPTCall_Settings = this.defaultSettings
+  ): Promise<string> {
+    const answer = await this.resolveSimpleUserMessage(question, issuer, messageSettings);
+
+    console.log(' - ', answer);
+
+    return answer;
+  }
+
+  /**
+   * olvasható mondatszerű-listaszerű formába teszi a listaelemeket
+   * pl.: ['a', 'b', 'c'] -> '"a", "b" or "c"'
+   */
+  getListAsText(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(', ');
+  }
+  
+  /**
+   * This function will log the question and the answer if the debugLog is true
+   */
+  async getAnswer(
+    question: string, 
+    issuer: string,
+    settings?: DyNTS_GPTCall_Settings
+  ): Promise<string> {
+    if (this.debugLog) {
+      console.log('\n - ', question);
+    }
+
+    const answer = await this.resolveSimpleUserMessage(question, issuer, settings);
+
+    if (this.debugLog) {
+      console.log(' - ', answer);
+    }
+
+    return answer;
+  }
+
+  async resolveSimpleUserMessage(
+    message: string,
+    issuer: string,
+    settings?: DyNTS_GPTCall_Settings
+  ): Promise<string> {
+    return this.resolveConversation(
+      [{ role: 'user', content: message }], 
+      issuer,
+      settings, 
+      false
+    ) as Promise<string>;
+  }
+
+  async resolveConversation(
+    conversation: DyNTS_GPT_Message[],
+    issuer: string,
+    settings?: DyNTS_GPTCall_Settings,
+    getFullResponse?: boolean
+  ): Promise<string | ChatCompletion> {
+    try {
+      const result: ChatCompletion = await this.openai.chat.completions.create(
+        this.getMessageCreateInput(conversation, 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`,
+      });
+    }
+  }
+
+  /**
+   * TODO: Overview this: maybe it should use each setting from default if not provided here
+   */
+  private getMessageCreateInput(
+    messages: DyNTS_GPT_Message[],
+    issuer: string,
+    settings: DyNTS_GPTCall_Settings = this.defaultSettings
+  ): ChatCompletionCreateParamsBase {
+    try {
+      messages.unshift(this.getDefaultSystemMessage(settings));
+
+      const result: ChatCompletionCreateParamsBase = {
+        model: settings.useModel ?? this.defaultModel,
+        messages: messages as ChatCompletionMessageParam[],
+      };
+
+      if (DyFM_notNull(settings.temperature)) {
+        result.temperature = settings.temperature;
+      }
+      
+      if (DyFM_notNull(settings.maxTokens)) {
+        result.max_tokens = settings.maxTokens;
+      }
+
+      if (DyFM_notNull(settings.topP)) {
+        result.top_p = settings.topP;
+      }
+
+      if (DyFM_notNull(settings.frequencyPenalty)) {
+        result.frequency_penalty = settings.frequencyPenalty;
+      }
+
+      if (DyFM_notNull(settings.presencePenalty)) {
+        result.presence_penalty = settings.presencePenalty;
+      }
+
+      return result;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('getMessageCreateSettings', error, issuer),
+        
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-OAB-RC0`,
+      });
+    }
+  }
+
+  private getDefaultSystemMessage(settings: DyNTS_GPTCall_Settings): DyNTS_GPT_Message {
+    return {
+      role: DyNTS_GPT_Message_Role.system,
+      content: settings.systemPrompt || this.defaultSystemPrompt,
+    };
+  }
+}
+
+export interface DyNTS_GPT_Message {
+  role: DyNTS_GPT_Message_Role | string;
+  content: string;
+}
+
+export enum DyNTS_GPT_Message_Role {
+  /**
+   * Developer-provided instructions that the model should follow, regardless of
+   * messages sent by the user. With o1 models and newer, `developer` messages
+   * replace the previous `system` messages.
+   */
+  developer = 'developer',
+  
+  /**
+   * Developer-provided instructions that the model should follow, regardless of
+   * messages sent by the user. With o1 models and newer, use `developer` messages
+   * for this purpose instead.
+   */
+  system = 'system',
+  
+  /**
+   * Messages sent by an end user, containing prompts or additional context
+   * information.
+   */
+  user = 'user',
+  
+  /**
+   * Messages sent by the model in response to user messages.
+   */
+  assistant = 'assistant',
+
+  /** ??? */
+  tool = 'tool',
+  
+  /**
+   * ???
+   * @deprecated
+   */
+  function = 'function',
+}
+
+export function DyFM_notNull(value: any): boolean {
+  return value !== null && value !== undefined;
+}

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

@@ -0,0 +1,73 @@
+
+import { OpenAI, ClientOptions } from 'openai';
+import { ChatCompletion, ChatCompletionMessageParam } from 'openai/resources';
+
+import { DyFM_AnyError, DyFM_Error, DyFM_Error_Settings, DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_OpenAIModel } from '../_enums/open-ai-model.enum';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_OpenAI_Settings } from '../_models/open-ai-settings.interface';
+import { DyNTS_GPTCall_Settings } from '../_models/gpt-call-settings.interface';
+
+
+/**
+ * {
+ *   organization: 'org-XY',
+ *   apiKey: 'sk-XY',
+ *   project: 'proj_XY',
+ * }
+ */
+
+// Di Dictionary DiModel DiEz DiAz
+
+export class DyNTS_OpenAI_ServiceBase {
+    
+  readonly defaultErrorUserMsg: string = 
+    `We encountered an unhandled Control Service Error, ` +
+    `\nplease contact the responsible development team.`; 
+
+  readonly openai: OpenAI;
+
+  /* readonly defaultSystemPrompt: string;
+  readonly defaultModel: DyNTS_OpenAIModel | string; */
+  readonly defaultSettings: DyNTS_GPTCall_Settings;
+
+  get debugLog(): boolean {
+    return this.defaultSettings.debugLog;
+  }
+
+  get defaultSystemPrompt(): string {
+    return this.defaultSettings.systemPrompt;
+  }
+
+  get defaultModel(): DyNTS_OpenAIModel | string {
+    return this.defaultSettings.useModel;
+  }
+
+  constructor(
+    set: DyNTS_OpenAI_Settings
+  ) {
+    this.openai = new OpenAI(set.openAIConfig);
+    this.defaultSettings = set.defaultSettings ?? new DyNTS_GPTCall_Settings();
+  }
+  
+  protected getDefaultErrorSettings(
+    fnName: string, 
+    error: DyFM_AnyError,
+    issuer: string
+  ): DyFM_Error_Settings {
+    return {
+      status: (error as DyFM_Error)?.___status ?? 500,
+      message: (error as Error)?.message ??
+        (error as DyFM_Error)?._message ??
+        `${fnName} was UNSUCCESSFUL (${DyNTS_global_settings.systemShortCodeName})`,
+      addECToUserMsg: !(error as DyFM_Error)?.__userMessage,
+      userMessage: (error as DyFM_Error)?.__userMessage ?? this.defaultErrorUserMsg,
+      issuer: issuer,
+      issuerService: this.constructor?.name,
+      error: error,
+    };
+  }
+}
+
+

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

@@ -0,0 +1,13 @@
+
+
+export * from './_enums/open-ai-model.enum';
+
+export * from './_models/gpt-call-settings.interface';
+export * from './_models/open-ai-api-env-settings.interface';
+export * from './_models/open-ai-settings.interface';
+
+export * from './_services/embedding.control-service';
+export * from './_services/gpt.service-base';
+export * from './_services/open-ai.service-base';
+
+

package/src/_modules/server/errors/errors.control-service.ts

@@ -25,7 +25,7 @@ export abstract class DyNTS_Errors_ControlService<
   readonly version: string = DyNTS_global_settings.systemVersion;
   duplicationCounter: number;
 
-  abstract recordError(data?: T_Errors, alwaysRecord?: boolean): Promise<void>;
+  abstract recordError(data: T_Errors, issuer: string, alwaysRecord?: boolean): Promise<void>;
 
   abstract handleInternalError(
     error: DyFM_AnyError | any, 
@@ -33,34 +33,37 @@ export abstract class DyNTS_Errors_ControlService<
     alwaysRecord?: boolean,
   ): Promise<void>;
 
-  abstract checkErrorIsStringifyableOrResolvable(error: T_Error): T_Error | 'UNRESOLVABLE';
+  abstract checkErrorIsStringifyableOrResolvable(error: T_Error, issuer: string): T_Error | 'UNRESOLVABLE';
 
-  abstract getPriorityMultiplierByLevel(level: DyFM_ErrorLevel): number;
+  abstract getPriorityMultiplierByLevel(level: DyFM_ErrorLevel, issuer: string): number;
 
   abstract getErrorsFromDate(
     date: Date,
     issuer: string,
   ): Promise<DyFM_Paged<T_Errors>>;
 
-  abstract deleteError(errorId: string, alwaysDelete?: boolean): Promise<void>;
+  abstract deleteError(errorId: string, issuer: string, alwaysDelete?: boolean): Promise<void>;
 
-  abstract deleteAllErrors(alwaysDelete?: boolean): Promise<void>;
+  abstract deleteAllErrors(issuer: string, alwaysDelete?: boolean): Promise<void>;
 
-  abstract getErrorsInRange(range: DyFM_RelativeDate): Promise<DyFM_Paged<T_Errors>>;
+  abstract getErrorsInRange(range: DyFM_RelativeDate, issuer: string): Promise<DyFM_Paged<T_Errors>>;
 
   abstract getErrorsPaged(
     range: DyFM_RelativeDate,
     pageSize: number,
     pageIndex: number,
+    issuer: string,
   ): Promise<DyFM_Paged<T_Errors>>;
 
   abstract getLastErrors(
     range: DyFM_RelativeDate,
     pageSize: number,
     pageIndex: number,
+    issuer: string,
   ): Promise<DyFM_Paged<T_Errors>>;
 
   abstract searchErrors(
     searchQuery: DyFM_SearchQuery<T_Errors>,
+    issuer: string,
   ): Promise<DyFM_SearchResult<T_Errors>>;
 }

package/src/_modules/server/errors/errors.controller.ts

@@ -71,12 +71,9 @@ export abstract class DyNTS_Errors_Controller<
         endpoint: '/error/log',
         tasks: [
           async (req: Request, res: Response, issuer?: string): Promise<void> => {
-            const error_CS: T_Error_ControlService = this.getError_ControlService({
-              data: req.body,
-              issuer: issuer ?? req.body?.issuer ?? 'unknown-client',
-            });
+            const error_CS: T_Error_ControlService = this.getError_ControlService();
 
-            await error_CS.recordError();
+            await error_CS.recordError(req.body, issuer ?? 'unknown-issuer');
 
             res.send({
               result: 'error logged',
@@ -91,11 +88,9 @@ export abstract class DyNTS_Errors_Controller<
         endpoint: '/error/mark-done/:errorId',
         tasks: [
           async (req: Request, res: Response, issuer?: string): Promise<void> => {
-            const error_CS: T_Error_ControlService = this.getError_ControlService({
-              issuer: issuer,
-            });
+            const error_CS: T_Error_ControlService = this.getError_ControlService();
   
-            await error_CS.deleteError(req.params.errorId, true);
+            await error_CS.deleteError(req.params.errorId, issuer ?? 'unknown-issuer', true);
   
             res.send({
               result: 'error deleted',
@@ -110,11 +105,9 @@ export abstract class DyNTS_Errors_Controller<
         endpoint: '/error/mark-all-done',
         tasks: [
           async (req: Request, res: Response, issuer?: string): Promise<void> => {
-            const error_CS: T_Error_ControlService = this.getError_ControlService({
-              issuer: issuer,
-            });
+            const error_CS: T_Error_ControlService = this.getError_ControlService();
   
-            await error_CS.deleteAllErrors(true);
+            await error_CS.deleteAllErrors(issuer ?? 'unknown-issuer', true);
   
             res.send({
               result: 'all error deleted',
@@ -149,12 +142,13 @@ export abstract class DyNTS_Errors_Controller<
         endpoint: '/error/get-range/:range',
         tasks: [
           async (req: Request, res: Response, issuer: string) : Promise<void> => {
-            const error_CS: T_Error_ControlService = this.getError_ControlService({
-              issuer: issuer,
-            });
+            const error_CS: T_Error_ControlService = this.getError_ControlService();
 
             res.send(
-              await error_CS.getErrorsInRange(req.params.range as DyFM_RelativeDate)
+              await error_CS.getErrorsInRange(
+                req.params.range as DyFM_RelativeDate, 
+                issuer ?? 'unknown-issuer'
+              )
             );
           },
         ],
@@ -166,9 +160,7 @@ export abstract class DyNTS_Errors_Controller<
         endpoint: '/error/get-paged/:range/:pageSize/:pageIndex',
         tasks: [
           async (req: Request, res: Response, issuer: string) : Promise<void> => {
-            const error_CS: T_Error_ControlService = this.getError_ControlService({
-              issuer: issuer,
-            });
+            const error_CS: T_Error_ControlService = this.getError_ControlService();
 
             let pageSize: number = req.params.pageSize ? +req.params.pageSize : 30;
             let pageIndex: number = req.params.pageIndex ? +req.params.pageIndex : 0;
@@ -183,7 +175,8 @@ export abstract class DyNTS_Errors_Controller<
               await error_CS.getErrorsPaged(
                 req.params.range as DyFM_RelativeDate, 
                 pageSize, 
-                pageIndex
+                pageIndex,
+                issuer ?? 'unknown-issuer'
               )
             );
           },
@@ -196,9 +189,7 @@ export abstract class DyNTS_Errors_Controller<
         endpoint: '/error/get-last-paged/:range/:pageSize/:pageIndex',
         tasks: [
           async (req: Request, res: Response, issuer: string) : Promise<void> => {
-            const error_CS: T_Error_ControlService = this.getError_ControlService({
-              issuer: issuer,
-            });
+            const error_CS: T_Error_ControlService = this.getError_ControlService();
 
             let pageSize: number = req.params.pageSize ? +req.params.pageSize : 30;
             let pageIndex: number = req.params.pageIndex ? +req.params.pageIndex : 0;
@@ -213,7 +204,8 @@ export abstract class DyNTS_Errors_Controller<
               await error_CS.getLastErrors(
                 req.params.range as DyFM_RelativeDate, 
                 pageSize, 
-                pageIndex
+                pageIndex,
+                issuer ?? 'unknown-issuer'
               )
             );
           },
@@ -226,12 +218,10 @@ export abstract class DyNTS_Errors_Controller<
         endpoint: '/error/search',
         tasks: [
           async (req: Request, res: Response, issuer: string) : Promise<void> => {
-            const error_CS: T_Error_ControlService = this.getError_ControlService({
-              issuer: issuer,
-            });
+            const error_CS: T_Error_ControlService = this.getError_ControlService();
 
             res.send(
-              await error_CS.searchErrors(req.body)
+              await error_CS.searchErrors(req.body, issuer ?? 'unknown-issuer')
             );
           },
         ],