@futdevpro/nts-dynamo 1.12.14 → 1.14.1

package/src/_modules/ai/_modules/open-ai/_services/oai-document.data-service.ts

@@ -0,0 +1,377 @@
+import { DyFM_Array, DyFM_DataModel_Params, DyFM_DBFilter, DyFM_DBFilterExpressions, DyFM_DBFilterSimple, DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_DataService } from '../../../../../_services/base/data.service';
+import { DyNTS_DAI_DocChunk } from '../../document-ai/_models/data-models/dai-doc-chunk.data-model';
+import { DyNTS_DAI_DocPage } from '../../document-ai/_models/data-models/dai-doc-page.data-model';
+import { DyNTS_DAI_Document, DyNTS_DAI_document_dataParams } from '../../document-ai/_models/data-models/dai-document.data-model';
+import { DyNTS_OAI_DocChunkDataService } from './oai-doc-chunk-data.service';
+import { DyNTS_OAI_DocPageDataService } from './oai-doc-page.data-service';
+import { DyFM_OAI_Settings } from '@futdevpro/fsm-dynamo/ai/open-ai';
+import { DyNTS_DAI_DocumentCompareResult } from '../../document-ai/_models/interfaces/dai-document-compare-result.interface';
+import { DyNTS_DAI_DocPageCompareResult } from '../../document-ai/_models/interfaces/dai-doc-page-compare-result.interface';
+import { DyNTS_DAI_CompareResult_Type } from '../../document-ai/_enums/dai-compare-result-type.enum';
+
+
+export class DyNTS_OAI_DocumentDataService<
+  T_Chunk extends DyNTS_DAI_DocChunk = DyNTS_DAI_DocChunk,
+  T_Page extends DyNTS_DAI_DocPage<T_Chunk> = DyNTS_DAI_DocPage<T_Chunk>,
+  T_ExternalDocumentId = string,
+  T_ExternalMetadata = any,
+  T_Document extends DyNTS_DAI_Document<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata> = DyNTS_DAI_Document<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata>,
+> extends DyNTS_DataService<T_Document> {
+
+  debugLog: boolean = true;
+  absoluteDeletesOnProcess: boolean = true;
+    
+  constructor(
+    issuer: string,
+    private docChunkDataServiceOpenAiSettings: DyFM_OAI_Settings,
+    data?: T_Document,
+    dataParams: DyFM_DataModel_Params<T_Document> = DyNTS_DAI_document_dataParams as DyFM_DataModel_Params<T_Document>,
+  ) {
+    super(
+      data,
+      dataParams,
+      issuer,
+    );
+  }
+
+  getDocPageDataService(): DyNTS_OAI_DocPageDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document> {
+    return new DyNTS_OAI_DocPageDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document>(
+      this.issuer,
+      this.docChunkDataServiceOpenAiSettings,
+    );
+  }
+
+  getDocChunkDataService(): DyNTS_OAI_DocChunkDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document> {
+    return new DyNTS_OAI_DocChunkDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document>(
+      this.issuer,
+      this.docChunkDataServiceOpenAiSettings,
+    );
+  }
+
+  async processDocuments(documents: T_Document[]): Promise<
+    DyNTS_DAI_DocumentCompareResult<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata, T_Document>[]
+  > {
+    try {
+      const compareResults: DyNTS_DAI_DocumentCompareResult<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata, T_Document>[] = [];
+
+      for (const document of documents) {
+        compareResults.push(await this.processDocument(document));
+      }
+
+      const deletedDocuments: T_Document[] = await this.findDataList({
+        _id: {
+          $nin: documents.map(document => document._id),
+        },
+      } as any as DyFM_DBFilter<T_Document>);
+
+      const docPage_DS: DyNTS_OAI_DocPageDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document> = 
+        this.getDocPageDataService();
+
+      const docChunk_DS: DyNTS_OAI_DocChunkDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document> = 
+        this.getDocChunkDataService();
+
+      for (const deletedDocument of deletedDocuments) {
+        const messages: string[] = [];
+
+        const chunksToDelete: T_Chunk[] = await docChunk_DS.findDataList({
+          documentId: deletedDocument._id,
+        } as DyFM_DBFilter<T_Chunk>);
+
+        for (const chunk of chunksToDelete) {
+          await docChunk_DS.deleteData(chunk._id, this.absoluteDeletesOnProcess);
+        }
+        messages.push(`${chunksToDelete.length} chunks deleted`);
+
+        const pagesToDelete: T_Page[] = await docPage_DS.findDataList({
+          documentId: deletedDocument._id,
+        } as DyFM_DBFilter<T_Page>);
+
+        for (const page of pagesToDelete) {
+          await docPage_DS.deleteData(page._id, this.absoluteDeletesOnProcess);
+        }
+        messages.unshift(`${pagesToDelete.length} pages deleted`);
+
+        await this.deleteData(deletedDocument._id, this.absoluteDeletesOnProcess);
+        messages.unshift(`Document "${deletedDocument.name}" deleted`);
+
+        compareResults.push({
+          result: DyNTS_DAI_CompareResult_Type.deleted,
+          newDocument: null,
+          oldDocument: deletedDocument,
+          pageCompareResults: [],
+          reports: messages,
+        });
+      }
+
+      for (const result of compareResults) {
+        // report the result
+        await this.reportDocumentProcessResult(result);
+      }
+
+      return compareResults;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('processDocuments', error),
+      });
+    }
+  }
+
+  async processDocument(document: T_Document): Promise<
+    DyNTS_DAI_DocumentCompareResult<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata, T_Document>
+  > {
+    try {
+      // ugyan a logikus az lenne, ha először compare-elnénk, és csak az után mentenénk, 
+      //   de akkor nem lenne id, amit a sub-element-ekhez kellenek, ezért...
+      // - először kikérjük a régi adatot, 
+      // - aztán mentünk, hogy legyen id, 
+      // - és utána compare-eljük
+
+
+      let existingDocument: T_Document; 
+
+      if (document._id) {
+        existingDocument = await this.findData({
+          _id: document._id,
+        } as DyFM_DBFilterSimple<T_Document>);
+      } else {
+        if (!document.externalDocumentId) {
+          throw new DyFM_Error({
+            ...this.getDefaultErrorSettings('processDocument', new Error('externalDocumentId is required')),
+            errorCode: 'OAI-DSB-PD0',
+          });
+        }
+
+        existingDocument = await this.findData({
+          externalDocumentId: document.externalDocumentId,
+        });
+      }
+
+      // save the document to ensure its id
+      let docDataToSave: T_Document;
+      if (existingDocument) {
+        docDataToSave = existingDocument;
+        Object.assign(docDataToSave, document);
+      } else {
+        docDataToSave = {
+          ...document,
+        };
+      };
+      delete docDataToSave.pages;
+
+      const savedDocument: T_Document = await this.saveData(docDataToSave, true);
+
+      // set the id to the pages and the document
+      document.pages.forEach((page: T_Page) => {
+        page.documentId = savedDocument._id;
+      });
+      document._id = savedDocument._id;
+
+      let documentCompareResult: DyNTS_DAI_DocumentCompareResult<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata, T_Document>;
+      if (existingDocument) {
+        documentCompareResult = await this.compareDocument_deep(document, existingDocument);
+      } else {
+        const docPage_DS: DyNTS_OAI_DocPageDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document> = 
+          this.getDocPageDataService();
+
+        const pagesCompareResults: DyNTS_DAI_DocPageCompareResult<T_Chunk, T_Page>[] = await docPage_DS.processNewPages(
+          savedDocument.pages,
+        );
+
+        documentCompareResult = {
+          result: DyNTS_DAI_CompareResult_Type.new,
+          newDocument: document,
+          oldDocument: null,
+          pageCompareResults: pagesCompareResults,
+          reports: [
+            `New document: ${document.name}`,
+            `${document.pages.length} new pages in ${document.name}`,
+          ],
+        };
+      }
+
+      return documentCompareResult;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('processDocument', error),
+      });
+    }
+  }
+
+  async compareDocument_deep(newDocument: T_Document, oldDocument: T_Document): Promise<
+    DyNTS_DAI_DocumentCompareResult<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata, T_Document>
+  > {
+    try {
+      if (this.debugLog) {
+        DyFM_Log.info(`🔍 Comparing ${this.dataParams.dataName} document: ${newDocument.name}`);
+      }
+
+      if (!oldDocument) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings('compareDocument_deep', new Error('oldDocument is required')),
+          errorCode: 'OAI-DSB-CD1',
+        });
+      }
+
+      const documentCompareResult_flat: DyNTS_DAI_DocumentCompareResult<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata, T_Document> = 
+        await this.compareDocument_flat(newDocument, oldDocument);
+      const messages: string[] = documentCompareResult_flat.reports;
+
+      const docPage_DS: DyNTS_OAI_DocPageDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document> = 
+        this.getDocPageDataService();
+
+      const pagesCompareResults: DyNTS_DAI_DocPageCompareResult<T_Chunk, T_Page>[] = await docPage_DS.processPages(
+        newDocument._id,
+        newDocument.pages,
+      );
+
+      // determine the result based on the pages
+      let pagesResult: DyNTS_DAI_CompareResult_Type;
+      if (pagesCompareResults.every(result => result.result === DyNTS_DAI_CompareResult_Type.equal)) {
+        pagesResult = DyNTS_DAI_CompareResult_Type.equal;
+        messages.push(`All pages are equal`);
+      } else if (
+        pagesCompareResults.some(
+          result => result.result === DyNTS_DAI_CompareResult_Type.new || 
+                    result.result === DyNTS_DAI_CompareResult_Type.modified ||
+                    result.result === DyNTS_DAI_CompareResult_Type.deleted
+        )
+      ) {
+        pagesResult = DyNTS_DAI_CompareResult_Type.modified;
+
+        const modifiedPagesCount: number = pagesCompareResults.filter(
+          result => result.result === DyNTS_DAI_CompareResult_Type.modified
+        ).length;
+        const deletedPagesCount: number = pagesCompareResults.filter(
+          result => result.result === DyNTS_DAI_CompareResult_Type.deleted
+        ).length;
+        const newPagesCount: number = pagesCompareResults.filter(
+          result => result.result === DyNTS_DAI_CompareResult_Type.new
+        ).length;
+
+        if (modifiedPagesCount > 0) {
+          messages.push(`${modifiedPagesCount} pages modified`);
+        }
+        if (newPagesCount > 0) {
+          messages.push(`${newPagesCount} pages new`);
+        }
+        if (deletedPagesCount > 0) {
+          messages.push(`${deletedPagesCount} pages deleted`);
+        }
+      } else {
+        pagesResult = DyNTS_DAI_CompareResult_Type.new;
+        const newPagesCount: number = pagesCompareResults.filter(
+          result => result.result === DyNTS_DAI_CompareResult_Type.new
+        ).length;
+        messages.push(`${newPagesCount} new pages`);        
+      }
+
+      // determine the result based on both the document and the pages
+      let documentResult: DyNTS_DAI_CompareResult_Type;
+      if (documentCompareResult_flat.result === DyNTS_DAI_CompareResult_Type.new) {
+        documentResult = DyNTS_DAI_CompareResult_Type.new;
+      } else if (documentCompareResult_flat.result === DyNTS_DAI_CompareResult_Type.modified) {
+        documentResult = DyNTS_DAI_CompareResult_Type.modified;
+      } else {
+        if (pagesResult === DyNTS_DAI_CompareResult_Type.equal) {
+          documentResult = DyNTS_DAI_CompareResult_Type.equal;
+        } {
+          documentResult = DyNTS_DAI_CompareResult_Type.modified;
+        }
+      }
+      
+      const result: DyNTS_DAI_DocumentCompareResult<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata, T_Document> = {
+        ...documentCompareResult_flat,
+        result: documentResult,
+
+        newDocument: newDocument,
+        oldDocument: oldDocument,
+
+        pageCompareResults: pagesCompareResults,
+      };
+
+      return result;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('compareDocument', error),
+      });
+    }
+  }
+
+  async compareDocument_flat(newDocument: T_Document, oldDocument: T_Document): Promise<
+    DyNTS_DAI_DocumentCompareResult<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata, T_Document>
+  > {
+    try {
+      if (!oldDocument) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings('compareDocument_flat', new Error('oldDocument is required')),
+          errorCode: 'OAI-DSB-CF1',
+        });
+      }
+
+      let result: DyNTS_DAI_CompareResult_Type;
+      const messages: string[] = [];
+
+      if (!oldDocument) {
+        result = DyNTS_DAI_CompareResult_Type.new;
+        messages.push(`New document: ${newDocument.name}`);
+      } else if (newDocument.name !== oldDocument?.name) {
+        result = DyNTS_DAI_CompareResult_Type.modified;
+        messages.push(`Document name changed from "${oldDocument?.name}" to "${newDocument.name}"`);
+      } else {
+        result = DyNTS_DAI_CompareResult_Type.equal;
+        messages.push(`Equal document: ${newDocument.name}`);
+      }
+
+      const result_flat: DyNTS_DAI_DocumentCompareResult<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata, T_Document> = {
+        result: result,
+        
+        newDocument: newDocument,
+        oldDocument: oldDocument,        
+
+        pageCompareResults: [],
+        reports: messages,
+      }
+
+      return result_flat;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('compareDocument_shallow', error),
+      });
+    }
+  }
+
+  async reportDocumentProcessResult(
+    documentCompareResult: DyNTS_DAI_DocumentCompareResult<T_Chunk, T_Page, T_ExternalDocumentId, T_ExternalMetadata, T_Document>, 
+  ): Promise<void> {
+    try {
+      DyFM_Log.log(`✅ Document processed: ${documentCompareResult.newDocument.name}`);
+
+      switch (documentCompareResult.result) {
+        case DyNTS_DAI_CompareResult_Type.new:
+          DyFM_Log.info(` ✨ New document`);
+          break;
+          
+        case DyNTS_DAI_CompareResult_Type.equal:
+          DyFM_Log.log(` 🟰 Equal document`);
+          break;
+
+        case DyNTS_DAI_CompareResult_Type.modified:
+          DyFM_Log.info(` 🔄 Modified document`);
+          break;
+
+        case DyNTS_DAI_CompareResult_Type.deleted:
+          DyFM_Log.warn(` ❌ Deleted document`);
+          break;
+      }
+
+      for (const report of documentCompareResult.reports) {
+        DyFM_Log.log(`  - ${report}`);
+      }
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('reportDocumentProcessing', error),
+      });
+    }
+  }
+}

package/src/_modules/{open-ai → ai/_modules/open-ai}/_services/oai-embedding.control-service.ts

@@ -1,15 +1,15 @@
-
-import { DyFM_OpenAIModel } from '@futdevpro/fsm-dynamo/open-ai';
+import { DyFM_OAI_Model } from '@futdevpro/fsm-dynamo/ai/open-ai';
 import { DyFM_Error } from '@futdevpro/fsm-dynamo';
 
 import { DyNTS_OAI_LLM_ServiceBase } from './oai-llm.service-base';
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
+import { DyNTS_AI_Embedding_ServiceBase } from '../../../_services/ai-embedding.service-base';
 
-export class DyNTS_OAI_Embedding_ControlService extends DyNTS_OAI_LLM_ServiceBase {
+export class DyNTS_OAI_Embedding_ControlService extends DyNTS_OAI_LLM_ServiceBase /* implements DyNTS_AI_Embedding_ServiceBase */ {
 
   async createEmbedding(
     text: string,
-    model: DyFM_OpenAIModel | string = DyFM_OpenAIModel.textEmbedding_3Large,
+    model: DyFM_OAI_Model | string = DyFM_OAI_Model.textEmbedding_3Large,
     issuer: string
   ): Promise<number[]> {
     try {
@@ -38,7 +38,7 @@ export class DyNTS_OAI_Embedding_ControlService extends DyNTS_OAI_LLM_ServiceBas
 
   async createEmbeddings(
     texts: string[],
-    model: DyFM_OpenAIModel | string = DyFM_OpenAIModel.textEmbedding_3Large,
+    model: DyFM_OAI_Model | string = DyFM_OAI_Model.textEmbedding_3Large,
     issuer: string
   ): Promise<number[][]> {
     try {

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

@@ -1,9 +1,9 @@
 import { OpenAI } from 'openai';
 
-import { DyFM_OpenAI_Settings, DyFM_OpenAIModel, DyFM_GPTCall_Settings } from '@futdevpro/fsm-dynamo/open-ai';
+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_getLocalStackLocation, DyFM_Log, DyFM_notNull, DyFM_Object, DyFM_Array } from '@futdevpro/fsm-dynamo';
 
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+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';
@@ -11,6 +11,7 @@ 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 { DyNTS_OAI_LLM_ServiceBase } from './oai-llm.service-base';
 import { DyNTS_OAI_global_settings } from '../_collections/oai-global-settings.const';
+import { DyNTS_AI_LLMChat_ServiceBase } from '../../../_services/ai-llm-chat.service-base';
 
 
 /**
@@ -23,7 +24,7 @@ import { DyNTS_OAI_global_settings } from '../_collections/oai-global-settings.c
 
 // 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 */ {
   
   /**
    * Asks the AI to answer a yes/no question
@@ -36,7 +37,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
       conversation: DyNTS_OAI_GPT_Message[],
       question: string, 
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */
       replaceThisInLog?: string,
@@ -62,7 +63,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
       conversation: DyNTS_OAI_GPT_Message[],
       question: string, 
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */
       replaceThisInLog?: string,
@@ -84,7 +85,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
       conversation: DyNTS_OAI_GPT_Message[],
       question: string, 
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */
       replaceThisInLog?: string,
@@ -121,7 +122,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
       question: string, 
       selectFrom: string[], 
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */
       replaceThisInLog?: string,
@@ -161,7 +162,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
       question: string,
       selectFrom: T[],
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */
       replaceThisInLog?: string,
@@ -192,7 +193,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
       question: string, 
       options: string[], 
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */
       replaceThisInLog?: string,
@@ -233,7 +234,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
       question: string,
       options: T[],
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */
       replaceThisInLog?: string,
@@ -267,7 +268,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
       conversation: DyNTS_OAI_GPT_Message[],
       question: string, 
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */
       replaceThisInLog?: string,
@@ -298,7 +299,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
       question: string, 
       keysDescription: string,
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */
       replaceThisInLog?: string,
@@ -333,7 +334,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
       question: string, 
       keys: string[],
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */
       replaceThisInLog?: string,
@@ -367,7 +368,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
       conversation: DyNTS_OAI_GPT_Message[],
       question: string, 
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */
       replaceThisInLog?: string,
@@ -393,7 +394,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
     question: string, 
     issuer: string,
     debugLog?: boolean,
-    messageSettings: DyFM_GPTCall_Settings = this.defaultSettings
+    messageSettings: DyFM_OAI_CallSettings = this.defaultSettings
   ): Promise<string> {
     const answer = await this.resolveSimpleUserMessageInConversation(
       conversation, 
@@ -414,7 +415,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
       conversation: DyNTS_OAI_GPT_Message[],
       question?: string, 
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */
       replaceThisInLog?: string,
@@ -442,7 +443,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
       conversation: DyNTS_OAI_GPT_Message[],
       newMessage?: string, 
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */
       replaceThisInLog?: string,
@@ -470,7 +471,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
     set: {
       conversation: DyNTS_OAI_GPT_Message[],
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       getFullResponse?: boolean,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */
@@ -489,7 +490,7 @@ export class DyNTS_OAI_LLMChat_ServiceBase extends DyNTS_OAI_LLM_ServiceBase {
     set: {
       conversation: DyNTS_OAI_GPT_Message[],
       issuer: string,
-      settings?: DyFM_GPTCall_Settings,
+      settings?: DyFM_OAI_CallSettings,
       getFullResponse?: boolean,
       debugLog?: boolean,
       /** this is used to readably replace too long contents to eg '...' in logs */