only_ever_generator 1.0.8 → 2.0.0

package/src/typology_gen/generate_concept_facts.ts

@@ -0,0 +1,54 @@
+import { OpenAIHelper } from "../helper/openai_helper";
+import { OpenAiService } from "../services/open_ai_service";
+
+export class GenerateConceptFacts {
+  public openAiService: OpenAiService;
+  public openAIHelper: OpenAIHelper;
+  public content: string;
+  public type: string = "";
+  public promptForConceptFacts: {
+    promptId: string;
+    version: string;
+  } = {
+    promptId: "",
+    version: "",
+  };
+  constructor(
+    openAiService: OpenAiService,
+    content: string,
+    type: string,
+    promptForConceptFacts: {
+      promptId: string;
+      version: string;
+    }
+  ) {
+    this.openAiService = openAiService;
+    this.openAIHelper = new OpenAIHelper(
+      this.openAiService.api_key,
+      this.openAiService.model,
+      this.promptForConceptFacts.promptId,
+      this.promptForConceptFacts.version
+    );
+    this.content = content;
+    this.promptForConceptFacts = promptForConceptFacts;
+    this.type = type;
+  }
+
+  async generate() {
+    console.log(this.promptForConceptFacts);
+    const openAiResponse = await this.openAIHelper.openAI.responses.create({
+      model: this.openAIHelper.model,
+      prompt: {
+        id: this.promptForConceptFacts.promptId,
+        version: this.promptForConceptFacts.version,
+        variables: {
+          heading_type: this.type == "video" ? "timecode" : "h1 heading",
+        },
+      },
+      input: this.content,
+      store: false,
+    });
+    console.log(openAiResponse.output_text);
+    return JSON.parse(openAiResponse.output_text);
+  }
+}

package/src/typology_gen/generate_typology.ts

@@ -1,50 +1,88 @@
+import { OpenAIHelper } from "../helper/openai_helper";
 import { ErrorLogger } from "../logger";
 import { OpenAiService } from "../services/open_ai_service";
 
 export class GenerateTypology {
   public openAiService: OpenAiService;
-  public prompt: string = "";
+  public type: string = "";
   public content: string = "";
+  public promptForTypology: {
+    promptId: string;
+    version: string;
+  } = {
+    promptId: "",
+    version: "",
+  };
   expectedFields: Array<string>;
   constructor(
     openAiService: OpenAiService,
-    prompt: string,
+    type: string,
     content: string,
-    expected_fields: Array<string>
+    expected_fields: Array<string>,
+    promptForTypology: {
+      promptId: string;
+      version: string;
+    }
   ) {
     this.openAiService = openAiService;
-    this.prompt = prompt;
+    this.type = type;
     this.content = content;
     this.expectedFields = expected_fields.map((elem: string) =>
       elem.toLowerCase()
     );
+    this.promptForTypology = promptForTypology;
   }
   async generate() {
     try {
-      const response = await this.openAiService?.sendRequest(
-        this.prompt,
-        this.content
+      // Use OpenAI Responses API
+      const openAIHelper = new OpenAIHelper(
+        this.openAiService.api_key,
+        this.openAiService.model,
+        this.promptForTypology.promptId,
+        this.promptForTypology.version
       );
-      response["request_type"] = {
+      const openAiResponse: any = await openAIHelper.openAI.responses.create({
+        model: openAIHelper.model,
+        prompt: {
+          id: openAIHelper.promptId,
+          version: openAIHelper.version,
+          variables: {
+            heading_type: this.type == "video" ? "timecode" : "h1 heading",
+          },
+        },
+        input: this.content,
+        store: false,
+      });
+      console.log(openAiResponse);
+
+      // const response = await this.openAiService?.sendRequest(
+      //   this.prompt,
+      //   this.content
+      // );
+      openAiResponse["request_type"] = {
         type: "breadth",
         n: 1,
       };
-      response.metadata = {
-        req_time: response.generated_at ?? new Date(),
+      openAiResponse.metadata = {
+        req_time: openAiResponse.created ?? new Date(),
         req_type: {
           type: "breadth",
           n: 1,
         },
-        req_tokens: response.usage_data?.prompt_tokens,
-        res_tokens: response.usage_data?.completion_tokens,
-        prompt_tokens_details: response.usage_data?.prompt_tokens_details,
+        req_tokens: openAiResponse.usage?.input_tokens ?? 0,
+        res_tokens: openAiResponse.usage?.output_tokens ?? 0,
+        prompt: openAiResponse.prompt,
+        // prompt_tokens_details: openAiResponse.usage?.,
         model: this.openAiService.model,
+        usage: openAiResponse.usage,
       };
-      if (response.status_code == 200) {
-        return this.parseTypologyOnSuccess(response);
+
+      if (openAiResponse.status == "completed") {
+        console.log("Completed");
+        return this.parseTypologyOnSuccess(openAiResponse);
       } else {
-        response.metadata.err_message = response.message;
-        return response;
+        openAiResponse.metadata.err_message = openAiResponse.message;
+        return openAiResponse;
       }
     } catch (e: any) {
       await new ErrorLogger({
@@ -56,28 +94,14 @@ export class GenerateTypology {
 
   parseTypologyOnSuccess(responseData: any) {
     responseData.metadata.status = "completed";
-    const generatedContent = responseData.generated_content;
-    const concepts = generatedContent.concepts.map((e: any) => {
-      return {
-        text: e.concept_text,
-        type: "concept",
-        reference: e.reference,
-      };
-    });
-    const facts = generatedContent.facts.map((e: any) => {
-      return {
-        text: e.fact_text,
-        type: "fact",
-        reference: e.reference,
-      };
-    });
+    const generatedContent = JSON.parse(responseData.output_text);
 
     return {
       status_code: 200,
       metadata: [responseData.metadata],
       field: this.parseFields(generatedContent.field),
-      concepts_facts: [...concepts, ...facts],
-      generate_cards: generatedContent.generate_cards,
+
+      generate_cards: generatedContent.learn_value,
       summary_cards: generatedContent.summary_cards,
       // type: responseData.type,
     };