only_ever_generator 0.2.6 → 0.2.7

package/dist/bootstrap/app.js

@@ -20,13 +20,10 @@ const generate_args_1 = require("../utils/generate_args");
 const calculate_gap_fill_1 = require("../gap_fill/calculate_gap_fill");
 /// OnlyEverGenerator
 class OnlyEverGenerator {
-    constructor(apiKey, model, generationContent
-    // prompt: any,
-    // content: any,
-    // expected_fields: Array<string>
-    ) {
+    constructor(apiKey, model, generationContent) {
         this.api_key = "";
-        this.parsedContent = "";
+        /// these fields will be populated inside the constructor
+        this.parsedContent = {};
         this.promptForTypology = "";
         this.promptForCardGen = "";
         this.typologyResponse = {};
@@ -35,72 +32,78 @@ class OnlyEverGenerator {
         this.gapFillResponse = {};
         this.api_key = apiKey;
         this.openAiService = new open_ai_service_1.OpenAiService(apiKey, model !== null && model !== void 0 ? model : "gpt-3.5-turbo-1106");
-        this.parsedContent = new parse_source_content_1.ParseSourceContent(generationContent.content).parseData();
+        const parsedData = new parse_source_content_1.ParseSourceContent(generationContent.content).parseData();
+        this.parsedContent = {
+            title: parsedData.title,
+            headings: parsedData.headings,
+            content: parsedData.content,
+        },
+            // parsedData.type == 'cards' ? this.typologyResponse = parsedData.taxonomy :  this.typologyResponse = null;
+            this.typologyResponse = parsedData.taxonomy;
         this.expectedFields = generationContent.content.fields; //returnFields();
         this.promptForTypology = (0, typology_prompt_1.returnTypologyPrompt)(generationContent.prompt.typology);
         this.promptForCardGen = (0, card_gen_prompt_1.returnCardGenPrompt)(generationContent.prompt.card_generation);
     }
     generate() {
         return __awaiter(this, arguments, void 0, function* (generate_typology = false, generate_card = false) {
-            var _a, _b, _c, _d;
-            //let typologyPrompt = returnTypologyPrompt();
-            let typologyPrompt = this.promptForTypology;
-            // let cardPrompt = returnCardGenPrompt();
-            let cardPrompt = this.promptForCardGen;
-            let args = new generate_args_1.GenerateArgs(generate_card, generate_typology, false, {
-                typology_prompt: typologyPrompt,
-                card_gen_prompt: cardPrompt,
-                summary_prompt: "",
-            });
+            let args = new generate_args_1.GenerateArgs(generate_card, generate_typology, false);
             const responseToReturn = [];
             const whatNeedsToBeGenerated = args.getWhatNeedsToBeGenerated();
             for (let elem of whatNeedsToBeGenerated)
                 if (elem == "generate_tyopology") {
-                    this.typologyResponse = yield this.generateTypology((_a = args.prompts.typology_prompt) !== null && _a !== void 0 ? _a : "");
+                    this.typologyResponse = yield this.generateTypology(this.promptForTypology);
                     responseToReturn.push(this.typologyResponse);
                 }
                 else if (elem == "generate_card") {
-                    if (this.typologyResponse.generate_cards) {
-                        if (this.typologyResponse.generate_cards.state == false) {
-                            console.log('Cards Generation Not Required');
+                    /// for cards gen to occur, there must be presence of source taxonomy
+                    if (this.shouldTheCardBeGeneratedAfterTypologyResponse()) {
+                        this.cardgenResponse = yield this.generateCard(this.promptForCardGen, JSON.stringify(this.typologyResponse), false);
+                        responseToReturn.push(this.cardgenResponse);
+                        /// check if gap fill is required ie coverage determination 
+                        if (this.cardgenResponse.status_code == 200) {
+                            this.gapFillResponse = yield this.generationForGapFill(this.typologyResponse, this.cardgenResponse);
+                            responseToReturn.push(this.gapFillResponse);
                         }
-                        else {
-                            this.cardgenResponse = yield this.generateCard((_b = args.prompts.card_gen_prompt) !== null && _b !== void 0 ? _b : "", this.parsedContent + JSON.stringify(this.typologyResponse), false);
-                        }
-                    }
-                    else {
-                        this.cardgenResponse = yield this.generateCard((_c = args.prompts.card_gen_prompt) !== null && _c !== void 0 ? _c : "", this.parsedContent, false);
                     }
-                    responseToReturn.push(this.cardgenResponse);
-                }
-            if (this.cardgenResponse.status_code == 200) {
-                let gapFill = (0, calculate_gap_fill_1.gapFilling)(this.typologyResponse, this.cardgenResponse);
-                if (gapFill.remainingConcepts.length !== 0 ||
-                    gapFill.remainingFacts.length !== 0) {
-                    this.gapFillResponse = yield this.generateCard((_d = args.prompts.card_gen_prompt) !== null && _d !== void 0 ? _d : "", this.parsedContent +
-                        "Generate cards only suitable for the given remaining concepts and facts" +
-                        JSON.stringify(gapFill) +
-                        "Exclude generating these cards" +
-                        JSON.stringify(this.cardgenResponse.cards_data), true);
                 }
-                responseToReturn.push(this.gapFillResponse);
-            }
             return responseToReturn;
             // return [typologyPrompt, cardPrompt];
         });
     }
-    generateCard(prompt, content, isGapFill) {
+    shouldTheCardBeGeneratedAfterTypologyResponse() {
+        if (this.typologyResponse) {
+            return this.typologyResponse.generate_cards.state == true;
+        }
+        else {
+            return false;
+        }
+    }
+    generationForGapFill(typologyData, cardGenData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let gapFill = (0, calculate_gap_fill_1.gapFilling)(typologyData, cardGenData);
+            let response;
+            if (gapFill.remainingConcepts.length !== 0 ||
+                gapFill.remainingFacts.length !== 0) {
+                response = yield this.generateCard(this.promptForCardGen +
+                    "Generate cards only suitable for the given remaining concepts and facts" +
+                    JSON.stringify(gapFill) +
+                    "Exclude generating these cards", JSON.stringify(cardGenData.cards_data), true);
+            }
+            return response;
+        });
+    }
+    generateCard(prompt, additionalContent, isGapFill) {
         return __awaiter(this, void 0, void 0, function* () {
             let generateCards = new generate_cards_1.GenerateCards(this.openAiService);
-            let cardgenResponse = yield generateCards.generateCards(prompt !== null && prompt !== void 0 ? prompt : "", content, isGapFill);
+            this.cardgenResponse = yield generateCards.generateCards(prompt !== null && prompt !== void 0 ? prompt : "", this.parsedContent + additionalContent, isGapFill);
             // let response =  await this.openAiService?.sendRequest(prompt,this.parsedContent);
             // response['type'] = 'card_gen';
-            return cardgenResponse;
+            return this.cardgenResponse;
         });
     }
     generateTypology(prompt) {
         return __awaiter(this, void 0, void 0, function* () {
-            let response = yield new generate_typology_1.GenerateTypology(this.openAiService, prompt, this.parsedContent, this.expectedFields).generate();
+            let response = yield new generate_typology_1.GenerateTypology(this.openAiService, prompt, JSON.stringify(this.parsedContent), this.expectedFields).generate();
             return response;
         });
     }

package/dist/card_gen/generate_cards.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenerateCards = void 0;
+const logger_1 = require("../logger");
 class GenerateCards {
     constructor(openAiService) {
         this.openAiService = openAiService;
@@ -39,42 +40,55 @@ class GenerateCards {
         });
     }
     parse(generatedData, isGapFill) {
-        const cardData = [];
-        let usage_data = generatedData.metadata;
-        const status_code = generatedData.status_code;
-        const missing_concepts = generatedData.generated_content.missing_concepts;
-        const missing_facts = generatedData.generated_content.missing_facts;
-        const unparsedTestCards = generatedData.generated_content.test_cards;
-        const type = generatedData.type;
-        if (unparsedTestCards !== undefined && unparsedTestCards.length != 0) {
-            for (let elem of unparsedTestCards) {
-                if (elem.type == "flash") {
-                    cardData.push(this.parseFlashCard(elem));
-                }
-                else if (elem.type == "mcq") {
-                    cardData.push(this.parseMcqCard(elem));
-                }
-                else if (elem.type == "cloze") {
-                    cardData.push(this.parseClozeCard(elem));
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const cardData = [];
+                let usage_data = generatedData.metadata;
+                const status_code = generatedData.status_code;
+                const missing_concepts = generatedData.generated_content.missing_concepts;
+                const missing_facts = generatedData.generated_content.missing_facts;
+                const unparsedTestCards = generatedData.generated_content.test_cards;
+                const type = generatedData.type;
+                if (unparsedTestCards !== undefined && unparsedTestCards.length != 0) {
+                    for (let elem of unparsedTestCards) {
+                        if (elem.type == "flash") {
+                            cardData.push(this.parseFlashCard(elem));
+                        }
+                        else if (elem.type == "mcq") {
+                            cardData.push(this.parseMcqCard(elem));
+                        }
+                        else if (elem.type == "cloze") {
+                            cardData.push(this.parseClozeCard(elem));
+                        }
+                        else if (elem.type == "match") {
+                            cardData.push(this.parseMatchCard(elem));
+                        }
+                    }
                 }
-                else if (elem.type == "match") {
-                    cardData.push(this.parseMatchCard(elem));
+                else {
+                    if (!isGapFill) {
+                        usage_data.status = "failed";
+                    }
                 }
+                return {
+                    status_code: status_code,
+                    metadata: usage_data,
+                    type: type,
+                    missing_concepts: missing_concepts,
+                    missing_facts: missing_facts,
+                    cards_data: cardData,
+                };
             }
-        }
-        else {
-            if (!isGapFill) {
-                usage_data.status = "failed";
+            catch (e) {
+                yield new logger_1.ErrorLogger({
+                    "type": 'card_parsing',
+                    "data": e.message,
+                }).log();
+                return {
+                    status_code: 500,
+                };
             }
-        }
-        return {
-            status_code: status_code,
-            metadata: usage_data,
-            type: type,
-            missing_concepts: missing_concepts,
-            missing_facts: missing_facts,
-            cards_data: cardData,
-        };
+        });
     }
     parseFlashCard(data) {
         let displayTitle = this.generateFlashCardDisplayTitle(data.card_content.front, data.card_content.back);

package/dist/logger.js

@@ -0,0 +1,41 @@
+"use strict";
+/// this method will call out atlas function and will write to a doc, incase of any errors: 
+/// this is only for developmemt use
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorLogger = void 0;
+const axios_1 = __importDefault(require("axios"));
+class ErrorLogger {
+    constructor(data) {
+        this.data = data;
+    }
+    log() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let response = yield axios_1.default.post('https://us-east-1.aws.data.mongodb-api.com/app/oe-phase1-tkmsy/endpoint/oe_gen_logger', {
+                    data: this.data,
+                }, {
+                    headers: {
+                        "Content-Type": ['application/json']
+                    }
+                });
+                return response;
+            }
+            catch (e) {
+                console.log(e);
+            }
+        });
+    }
+}
+exports.ErrorLogger = ErrorLogger;

package/dist/parse/parse_source_content.js

@@ -7,18 +7,32 @@ class ParseSourceContent {
         this.content = sourceContent;
     }
     parseData() {
-        if (this.content.type == 'source') {
-            let dataAfterRemovingUnWantedBlocks = this.removeSectionsByTitle(this.content.content);
-            let afterSanitized = this.sanitizeBlocks(dataAfterRemovingUnWantedBlocks);
-            return JSON.stringify([
-                { 'title': this.content.title },
-                { 'headings': this.content.headings },
-                { 'content': afterSanitized }
-            ]);
+        // if(this.content.type == 'source') {
+        let dataAfterRemovingUnWantedBlocks = this.removeSectionsByTitle(this.content.content);
+        let afterSanitized = this.sanitizeBlocks(dataAfterRemovingUnWantedBlocks);
+        let taxonomy;
+        if (this.content.taxonomy) {
+            taxonomy = this.content.taxonomy;
         }
         else {
-            return '';
+            taxonomy = null;
         }
+        return {
+            type: this.content.type,
+            title: this.content.title,
+            content: afterSanitized,
+            headings: this.content.headings,
+            taxonomy: this.content.taxonomy,
+        };
+        // } else if(this.content.type == 'cards'){
+        //     return {
+        //         type :'card',
+        //         title: this.content.title,
+        //         content: afterSanitized,
+        //         headings: this.content.headings
+        //         taxonomy: this.content.taxonomy,
+        //     };
+        // }
         //  return JSON.stringify(afterSanitized);    
     }
     removeSectionsByTitle(data) {

package/dist/typology_gen/generate_typology.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenerateTypology = void 0;
+const logger_1 = require("../logger");
 class GenerateTypology {
     constructor(openAiService, prompt, content, expected_fields) {
         this.prompt = '';
@@ -22,19 +23,27 @@ class GenerateTypology {
     generate() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
-            const response = yield ((_a = this.openAiService) === null || _a === void 0 ? void 0 : _a.sendRequest(this.prompt, this.content));
-            response['type'] = 'typology';
-            response.metadata = {
-                "req_time": response.generated_at,
-                "req_type": response.type,
-                "req_tokens": (_b = response.usage_data) === null || _b === void 0 ? void 0 : _b.prompt_tokens,
-                "res_tokens": (_c = response.usage_data) === null || _c === void 0 ? void 0 : _c.completion_tokens,
-            };
-            if (response.status_code == 200) {
-                return this.parseTypologyOnSuccess(response);
+            try {
+                const response = yield ((_a = this.openAiService) === null || _a === void 0 ? void 0 : _a.sendRequest(this.prompt, this.content));
+                response['type'] = 'typology';
+                response.metadata = {
+                    "req_time": response.generated_at,
+                    "req_type": response.type,
+                    "req_tokens": (_b = response.usage_data) === null || _b === void 0 ? void 0 : _b.prompt_tokens,
+                    "res_tokens": (_c = response.usage_data) === null || _c === void 0 ? void 0 : _c.completion_tokens,
+                };
+                if (response.status_code == 200) {
+                    return this.parseTypologyOnSuccess(response);
+                }
+                else {
+                    return response;
+                }
             }
-            else {
-                return response;
+            catch (e) {
+                yield new logger_1.ErrorLogger({
+                    "type": 'typology_parsing',
+                    "data": e.message
+                }).log();
             }
         });
     }

package/dist/utils/generate_args.js

@@ -2,23 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenerateArgs = void 0;
 class GenerateArgs {
-    constructor(generate_card, generate_typology, generate_summary, prompts = {
-        typology_prompt: '',
-        card_gen_prompt: '',
-        summary_prompt: ''
-    }) {
+    constructor(generate_card, generate_typology, generate_summary) {
         this.generate_card = false;
         this.generate_typology = false;
         this.generate_summary = false;
-        this.prompts = {
-            typology_prompt: '',
-            card_gen_prompt: '',
-            summary_prompt: ''
-        };
         this.generate_card = generate_card;
         this.generate_typology = generate_typology;
         this.generate_summary = generate_summary;
-        this.prompts = prompts;
     }
     getWhatNeedsToBeGenerated() {
         let returnData = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "only_ever_generator",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "main": "dist/index.js",
   "scripts": {
     "start": "npm run build && nodemon dist/index.js",

package/src/bootstrap/app.ts

@@ -8,6 +8,8 @@ import { GenerateArgs } from "../utils/generate_args";
 import { returnFields } from "../constants/source_data";
 import { returnTypologyData } from "../parse/response_format_typology";
 import { gapFilling } from "../gap_fill/calculate_gap_fill";
+import { title } from "process";
+import { ErrorLogger } from "../logger";
 
 
 /// OnlyEverGenerator
@@ -15,122 +17,133 @@ import { gapFilling } from "../gap_fill/calculate_gap_fill";
 export class OnlyEverGenerator {
   public api_key: string = "";
   public openAiService: OpenAiService;
-  parsedContent: string = "";
+
+/// these fields will be populated inside the constructor
+  parsedContent: any = {};
   promptForTypology: string = "";
   promptForCardGen: string = "";
   expectedFields: Array<string>;
+
+
+  typologyResponse: any = {};
+  cardgenResponse: any = {};
+  summarizeResponse = {};
+  gapFillResponse: any = {};
+
+
   constructor(
     apiKey: string,
     model: string,
     generationContent : any
-    // prompt: any,
-    // content: any,
-    // expected_fields: Array<string>
   ) {
     this.api_key = apiKey;
     this.openAiService = new OpenAiService(
       apiKey,
       model ?? "gpt-3.5-turbo-1106"
     );
+    const parsedData = new ParseSourceContent(generationContent.content).parseData()
+    this.parsedContent = {
+      title: parsedData.title,
+      headings: parsedData.headings,
+      content: parsedData.content,
+
+    },
+    // parsedData.type == 'cards' ? this.typologyResponse = parsedData.taxonomy :  this.typologyResponse = null;
+    this.typologyResponse = parsedData.taxonomy
     
-    this.parsedContent = new ParseSourceContent(generationContent.content).parseData();
     this.expectedFields =  generationContent.content.fields; //returnFields();
     this.promptForTypology = returnTypologyPrompt(generationContent.prompt.typology);
     this.promptForCardGen = returnCardGenPrompt(generationContent.prompt.card_generation);
   }
 
-  typologyResponse: any = {};
-  cardgenResponse: any = {};
-  summarizeResponse = {};
-  gapFillResponse: any = {};
 
  
   async generate(
     generate_typology: boolean = false,
     generate_card: boolean = false
   ): Promise<Array<any>> {
-    //let typologyPrompt = returnTypologyPrompt();
-    let typologyPrompt = this.promptForTypology;
-
-   // let cardPrompt = returnCardGenPrompt();
-   let cardPrompt = this.promptForCardGen;
-    let args = new GenerateArgs(generate_card, generate_typology, false, {
-      typology_prompt: typologyPrompt,
-      card_gen_prompt: cardPrompt,
-      summary_prompt: "",
-    });
+    let args = new GenerateArgs(generate_card, generate_typology, false, );
     const responseToReturn = [];
     const whatNeedsToBeGenerated = args.getWhatNeedsToBeGenerated();
     for (let elem of whatNeedsToBeGenerated)
       if (elem == "generate_tyopology") {
         this.typologyResponse = await this.generateTypology(
-          args.prompts.typology_prompt ?? ""
+        this.promptForTypology
         );
         responseToReturn.push(this.typologyResponse);
       } else if (elem == "generate_card") {
-        if(this.typologyResponse.generate_cards){
-          if(this.typologyResponse.generate_cards.state == false){
-          console.log('Cards Generation Not Required');
-        }else{
-          this.cardgenResponse = await this.generateCard(
-            args.prompts.card_gen_prompt ?? "",
-            this.parsedContent + JSON.stringify(this.typologyResponse),
-            false
-          );
+        /// for cards gen to occur, there must be presence of source taxonomy
+        if(this.shouldTheCardBeGeneratedAfterTypologyResponse()){
+          this.cardgenResponse =  await this.generateCard(
+            this.promptForCardGen,
+            JSON.stringify(this.typologyResponse),
+            false,
+          )
+          responseToReturn.push(this.cardgenResponse);
+
+          /// check if gap fill is required ie coverage determination 
+          if(this.cardgenResponse.status_code == 200) {
+            this.gapFillResponse = await this.generationForGapFill(this.typologyResponse, this.cardgenResponse);
+            responseToReturn.push(this.gapFillResponse);
+          }
+
         }
-      }
+    }
+    return responseToReturn;
+   // return [typologyPrompt, cardPrompt];
+  
+  }
 
-        else{
-        this.cardgenResponse = await this.generateCard(
-          args.prompts.card_gen_prompt ?? "",
-          this.parsedContent,
-          false
-        );
-        
-      }
-      responseToReturn.push(this.cardgenResponse);
+  shouldTheCardBeGeneratedAfterTypologyResponse(){
+    if(this.typologyResponse){
+      return this.typologyResponse.generate_cards.state == true;
+    }else{
+      return false;
     }
-    if (this.cardgenResponse.status_code == 200) {
-      let gapFill = gapFilling(this.typologyResponse, this.cardgenResponse);
+
+  }
+
+  async generationForGapFill(typologyData: any, cardGenData: any) {
+      let gapFill = gapFilling(typologyData, cardGenData);
+      let response :any ;
       if (
         gapFill.remainingConcepts.length !== 0 ||
         gapFill.remainingFacts.length !== 0
       ) {
-        this.gapFillResponse = await this.generateCard(
-          args.prompts.card_gen_prompt ?? "",
-          this.parsedContent +
+        response = await this.generateCard(
+         this.promptForCardGen +
             "Generate cards only suitable for the given remaining concepts and facts" +
             JSON.stringify(gapFill) +
-            "Exclude generating these cards" +
-            JSON.stringify(this.cardgenResponse.cards_data),
+            "Exclude generating these cards",
+            JSON.stringify(cardGenData.cards_data),
           true
         );
       }
-      responseToReturn.push(this.gapFillResponse);
-    }
- 
-    return responseToReturn;
-   // return [typologyPrompt, cardPrompt];
-  
+      return response;
+    
   }
 
-  async generateCard(prompt: string, content: string, isGapFill: boolean) {
+
+
+  async generateCard(prompt: string, additionalContent: string, isGapFill: boolean) {
     let generateCards = new GenerateCards(this.openAiService);
-    let cardgenResponse = await generateCards.generateCards(
+    this.cardgenResponse = await generateCards.generateCards(
       prompt ?? "",
-      content,
+      this.parsedContent + additionalContent,
       isGapFill
     );
+  
     // let response =  await this.openAiService?.sendRequest(prompt,this.parsedContent);
     // response['type'] = 'card_gen';
-    return cardgenResponse;
+    return this.cardgenResponse;
   }
 
+
   async generateTypology(prompt: string) {
     let response = await new GenerateTypology(
       this.openAiService,
       prompt,
-      this.parsedContent,
+      JSON.stringify(this.parsedContent),
       this.expectedFields
     ).generate();
     return response;

package/src/card_gen/generate_cards.ts

@@ -1,3 +1,4 @@
+import { ErrorLogger } from "../logger";
 import { OpenAiService } from "../services/open_ai_service";
 
 export class GenerateCards {
@@ -27,7 +28,8 @@ export class GenerateCards {
       }
   }
 
-  parse(generatedData: any, isGapFill: boolean) {
+  async parse(generatedData: any, isGapFill: boolean) {
+    try{
     const cardData = [];
     let usage_data = generatedData.metadata;
     const status_code = generatedData.status_code;
@@ -63,6 +65,16 @@ if(unparsedTestCards !== undefined && unparsedTestCards.length != 0) {
       missing_facts: missing_facts,
       cards_data: cardData,
     };
+  }catch (e:any){
+    await new ErrorLogger({
+      "type": 'card_parsing',
+      "data": e.message,
+     }).log();
+     return {
+      status_code: 500,
+      
+     }
+  }
   }
 
   parseFlashCard(data: any) {

package/src/index.ts

@@ -11,7 +11,7 @@ import { OnlyEverGenerator } from "./bootstrap/app";
 
 /// While Publishing the package , and using this code as a separate npm module
 /// uncomment the below line and comment all the others, expect the import of OnlyEverGenerator
- export {OnlyEverGenerator};
+  export {OnlyEverGenerator};
 
 //. All the Codes Below uses express and are strictly for development purpose, while publishing the package, comment everything
 //below this line

package/src/logger.ts

@@ -0,0 +1,31 @@
+/// this method will call out atlas function and will write to a doc, incase of any errors: 
+/// this is only for developmemt use
+
+import axios from "axios";
+
+
+export class ErrorLogger{
+    data: any;
+    constructor(data: any){
+        this.data = data;
+    }
+
+    async log() {
+        try{
+       let response = await axios.post(
+            'https://us-east-1.aws.data.mongodb-api.com/app/oe-phase1-tkmsy/endpoint/oe_gen_logger',
+            {
+                data: this.data,
+            },
+            {
+                headers : {
+                    "Content-Type" : ['application/json']
+                }
+            }
+
+        );
+    return response;}catch(e){
+        console.log(e)
+    }
+    }
+}

package/src/parse/parse_source_content.ts

@@ -8,18 +8,31 @@ export class ParseSourceContent{
     }
 
     parseData() {
-        if(this.content.type == 'source') {
+        // if(this.content.type == 'source') {
             let dataAfterRemovingUnWantedBlocks = this.removeSectionsByTitle(this.content.content);
             let afterSanitized = this.sanitizeBlocks(dataAfterRemovingUnWantedBlocks);
-            return JSON.stringify([
-                {'title': this.content.title},
-                {'headings': this.content.headings},
-                {'content': afterSanitized}
-    
-            ]);
-        } else {
-            return '';
-        }
+            let taxonomy;
+            if(this.content.taxonomy){
+                taxonomy = this.content.taxonomy
+            }else{
+                taxonomy = null;
+            }
+            return {
+                type: this.content.type,
+                title: this.content.title,
+                content: afterSanitized,
+                headings: this.content.headings,
+                taxonomy: this.content.taxonomy,
+            }
+        // } else if(this.content.type == 'cards'){
+        //     return {
+        //         type :'card',
+        //         title: this.content.title,
+        //         content: afterSanitized,
+        //         headings: this.content.headings
+        //         taxonomy: this.content.taxonomy,
+        //     };
+        // }
        
       //  return JSON.stringify(afterSanitized);    
     }

package/src/services/open_ai_service.ts

@@ -1,6 +1,7 @@
 import axios from "axios";
 import { parseOpenAiFailureResponse, parseOpenAiSuccessResponse } from "../utils/parse_openai_response";
 import { openAiEndPoint } from "../constants/api_constants";
+import { ErrorLogger } from "../logger";
 
 
 export class OpenAiService{

package/src/typology_gen/generate_typology.ts

@@ -1,5 +1,6 @@
 import { OpenAiService } from "../services/open_ai_service";
 import { returnTypologyData } from "../parse/response_format_typology";
+import { ErrorLogger } from "../logger";
 
 export class GenerateTypology{
     public openAiService: OpenAiService;
@@ -13,6 +14,7 @@ export class GenerateTypology{
         this.expectedFields = expected_fields.map((elem:string)=>elem.toLowerCase());
     }
     async generate(){
+      try{
       const response =  await this.openAiService?.sendRequest(this.prompt,this.content);
       response['type'] = 'typology';
       response.metadata = {
@@ -25,6 +27,11 @@ export class GenerateTypology{
         return this.parseTypologyOnSuccess(response);
       } else {
         return response;
+      }} catch (e: any){
+        await new ErrorLogger({
+          "type": 'typology_parsing',
+          "data": e.message
+         }).log();
       }
     }
 

package/src/utils/generate_args.ts

@@ -2,21 +2,12 @@ export class GenerateArgs{
     public generate_card : boolean = false;
     public generate_typology: boolean = false;
     public generate_summary: boolean = false;
-    public prompts = {
-        typology_prompt: '',
-        card_gen_prompt: '',
-        summary_prompt: ''
-    }
 
-    constructor(generate_card: boolean,generate_typology: boolean, generate_summary: boolean, prompts = {
-        typology_prompt: '',
-        card_gen_prompt: '',
-        summary_prompt: ''
-    }){
+    constructor(generate_card: boolean,generate_typology: boolean, generate_summary: boolean, ){
         this.generate_card = generate_card;
         this.generate_typology = generate_typology;
         this.generate_summary = generate_summary;
-        this.prompts = prompts
+
     }
 
     getWhatNeedsToBeGenerated(){