only_ever_generator 8.4.6 → 8.4.8

package/src/card_gen/generate_cards.ts

@@ -1,345 +1,347 @@
-import { OpenAIHelper } from "../helper/openai_helper";
-import { buildCardSchema } from "../helper/schema_helper/build_card_schema";
-import { ErrorLogger, log_error, ParsingError } from "../logger";
-import { ParseCardResponse } from "../parse/parse_card_response";
-import { OpenAiService } from "../services/open_ai_service";
-import { GeneratedCardResponseType } from "../types/raw_card_response_types/generated_card_response_type";
-import { SourceTaxonomy } from "../types/source_taxonomy_type";
-import { ParsedCardType } from "../types/parsed_card_type";
-import axios from "axios";
-import { GenerationVariablesSchema } from "../types/generation_variables_schema";
-import { promptIds } from "../services/get_prompts";
-
-// Type for the response structure returned by generateCardsForType
-type GenerateCardsResponse = {
-  status_code: number;
-  metadata: any;
-  type: string;
-  cards_data?: ParsedCardType[];
-};
-
-// Type for list/array of GenerateCardsResponse (including undefined)
-export type GenerateCardsResponseList = (GenerateCardsResponse | undefined)[];
-
-export class GenerateCards {
-  openAiService: OpenAiService;
-  public content: string;
-  public sourceId: string;
-  public taxonomy: SourceTaxonomy;
-  public source_type: string;
-  openAIHelper: OpenAIHelper;
-  public generationCurriculum: boolean;
-  public generationVariablesSchema: GenerationVariablesSchema;
-  constructor(
-    openAiService: OpenAiService,
-    sourceId: string,
-    content: string,
-    taxonomy: SourceTaxonomy,
-    generationCurriculum: boolean,
-    source_type: string,
-    generationVariablesSchema: GenerationVariablesSchema
-  ) {
-    this.openAiService = openAiService;
-    this.openAIHelper = new OpenAIHelper(this.openAiService.api_key);
-    this.sourceId = sourceId;
-    this.content = content;
-    this.taxonomy = taxonomy;
-    this.generationCurriculum = generationCurriculum;
-    this.source_type = source_type;
-    this.generationVariablesSchema = generationVariablesSchema;
-  }
-
-  async openAIResponse(card_generation_types: string[]) {
-    const concepts = this.taxonomy.concepts_facts
-      .filter((concept) => concept.type === "concept")
-      .map((concept) => concept.text);
-    const facts = this.taxonomy.concepts_facts
-      .filter((fact) => fact.type === "fact")
-      .map((fact) => fact.text);
-
-    // Extract instructions and examples from generationVariablesSchema.cards
-    const cardInstructions = card_generation_types
-      .map(
-        (type) => this.generationVariablesSchema.cards[type]?.instructions || ""
-      )
-      .join("\n\n");
-
-    const cardExamples = card_generation_types
-      .map((type) => this.generationVariablesSchema.cards[type]?.examples || "")
-      .join("\n\n");
-
-    const schema = await buildCardSchema(
-      concepts,
-      facts,
-      card_generation_types,
-      this.generationVariablesSchema.cards
-    );
-    try {
-      let response: any = await this.openAIHelper.openAI.responses.create({
-        prompt: {
-          id: promptIds.cardGeneration,
-          variables: {
-            bloom_level: "1",
-            card_types: card_generation_types.join(","),
-            bloom_instructions:
-              this.generationVariablesSchema.bloom_instructions,
-            card_instructions: cardInstructions,
-            card_examples: cardExamples,
-          },
-        },
-        max_output_tokens: 30000,
-
-        input: [
-          {
-            role: "user",
-            content: [{ type: "input_text", text: this.content }],
-          },
-        ],
-        store: true,
-        text: {
-          format: {
-            type: "json_schema",
-            name: schema.name,
-            strict: schema.strict,
-            schema: schema.schema,
-          },
-        },
-      });
-
-      if (!response) {
-        await log_error({
-          flow: this.generationCurriculum
-            ? "curriculum_manual_generation"
-            : "manual_generation",
-          data: JSON.stringify(response),
-          timestamp: new Date(),
-          error: "empty_openai_response",
-          source_id: this.sourceId,
-          type: {
-            request_type: "depth",
-            n: 1,
-          },
-        });
-        return;
-      }
-
-      return response;
-    } catch (error) {
-      if (error instanceof ParsingError) {
-        await log_error({
-          flow: this.generationCurriculum
-            ? "curriculum_manual_generation"
-            : "manual_generation",
-          data: error,
-          timestamp: new Date(),
-          error: "parsing_error",
-          source_id: this.sourceId,
-          type: {
-            request_type: "depth",
-            n: 1,
-            card_types: card_generation_types.join(","),
-          },
-        });
-      } else {
-        console.log(error);
-        await log_error({
-          flow: this.generationCurriculum
-            ? "curriculum_manual_generation"
-            : "manual_generation",
-          data: error,
-          timestamp: new Date(),
-          error: "error_in_card_generation",
-          source_id: this.sourceId,
-          type: {
-            request_type: "depth",
-            n: 1,
-            card_types: card_generation_types.join(","),
-          },
-        });
-      }
-    }
-  }
-
-  async generateCards(
-    n: number,
-    card_generation_types: string[]
-  ): Promise<GenerateCardsResponseList> {
-    try {
-      // Use Promise.allSettled to allow individual types to fail without affecting others
-      const settledResponses = await Promise.allSettled(
-        card_generation_types.map(async (card_generation_type) => {
-          return await this.generateCardsForType(n, card_generation_type);
-        })
-      );
-
-      // Extract fulfilled responses and log rejected ones
-      let responses: GenerateCardsResponseList = settledResponses
-        .map((result, index) => {
-          if (result.status === "fulfilled") {
-            if (result.value) {
-              return result.value;
-            } else {
-              // Log when fulfilled but value is undefined
-              console.error(
-                `Card generation for type ${card_generation_types[index]} returned undefined`
-              );
-              log_error({
-                flow: this.generationCurriculum
-                  ? "curriculum_manual_generation"
-                  : "manual_generation",
-                data: "Fulfilled promise returned undefined value",
-                timestamp: new Date(),
-                error: "undefined_value_in_card_generation",
-                source_id: this.sourceId,
-                type: {
-                  request_type: "depth",
-                  n: n,
-                  card_types: card_generation_types[index],
-                },
-              });
-              return undefined;
-            }
-          } else {
-            // Log the rejection but continue with other types
-            console.error(
-              `Failed to generate cards for type ${card_generation_types[index]}:`,
-              result.reason
-            );
-            log_error({
-              flow: this.generationCurriculum
-                ? "curriculum_manual_generation"
-                : "manual_generation",
-              data: result.reason,
-              timestamp: new Date(),
-              error: "error_in_card_generation_for_type",
-              source_id: this.sourceId,
-              type: {
-                request_type: "depth",
-                n: n,
-                card_types: card_generation_types[index],
-              },
-            });
-            return undefined;
-          }
-        })
-        .filter(
-          (response): response is GenerateCardsResponse =>
-            response !== undefined
-        );
-
-      // Flatten all parsed cards from all responses
-      // const allParsedCards: AllParsedCards = [];
-      // for (const response of responses) {
-      //   if (response && response.cards_data) {
-      //     allParsedCards.push(...response.cards_data);
-      //   }
-      // }
-
-      return responses;
-    } catch (e: any) {
-      await log_error({
-        flow: this.generationCurriculum
-          ? "curriculum_manual_generation"
-          : "manual_generation",
-        data: e,
-        timestamp: new Date(),
-        error: "error_in_card_generation",
-        source_id: this.sourceId,
-        type: {
-          request_type: "depth",
-          n: n,
-        },
-      });
-      return [];
-    }
-  }
-
-  async generateCardsForType(
-    n: number,
-    card_generation_type: string
-  ): Promise<GenerateCardsResponse | undefined> {
-    try {
-      let response = await this.openAIResponse([card_generation_type]);
-      response.metadata = {
-        req_time: response.generated_at ?? new Date(),
-        req_type: {
-          type: "depth",
-          n: n,
-          card_types: card_generation_type,
-          bloom_level: 1,
-        },
-        req_tokens: response.usage_data?.prompt_tokens,
-        res_tokens: response.usage_data?.completion_tokens,
-        prompt: {
-          id: response.prompt.id,
-          version: response.prompt.version,
-        },
-        prompt_tokens_details: response.usage_data?.prompt_tokens_details,
-        model: response.model,
-      };
-      if (response.status == "completed") {
-        response.metadata.status = "completed";
-        /// map response to generated_content
-
-        const testCardsArray = this.parseJson(response);
-        const generated_data: GeneratedCardResponseType = {
-          metadata: response.metadata,
-          generated_content: {
-            test_cards: testCardsArray.map((card: any) => {
-              return {
-                type: card.type,
-                card_content: card.card_content,
-                concepts: card.concepts ?? [],
-                facts: card.facts ?? [],
-                bloom_level: card.bloom_level ?? 1,
-                explanation: card.explanation ?? "",
-              };
-            }),
-          },
-          usage_data: response.usage,
-          generated_at: response.created_at,
-          status_code: response.status == "completed" ? 200 : 400,
-        };
-        let parseCard = new ParseCardResponse().parse(
-          generated_data,
-          this.taxonomy,
-          1
-        );
-        return parseCard;
-      } else {
-        response.metadata.status = "failed";
-        response.metadata.err_message = response.message;
-        return response;
-      }
-    } catch (e: any) {
-      await log_error({
-        flow: this.generationCurriculum
-          ? "curriculum_manual_generation"
-          : "manual_generation",
-        data: e,
-        timestamp: new Date(),
-        error: "error_in_card_generation",
-        source_id: this.sourceId,
-        type: {
-          request_type: "depth",
-          n: n,
-          card_types: card_generation_type,
-          bloom_level: 1,
-        },
-      });
-      return undefined;
-    }
-  }
-
-  parseJson(response: any) {
-    try {
-      const testCardsArray = JSON.parse(response.output_text).test_cards;
-      return testCardsArray;
-    } catch (e) {
-      throw new ParsingError(
-        "Something went wrong in parsing the json",
-        response
-      );
-    }
-  }
-}
+import { OpenAIHelper } from "../helper/openai_helper";
+import { buildCardSchema } from "../helper/schema_helper/build_card_schema";
+import { ErrorLogger, log_error, ParsingError } from "../logger";
+import { ParseCardResponse } from "../parse/parse_card_response";
+import { OpenAiService } from "../services/open_ai_service";
+import { GeneratedCardResponseType } from "../types/raw_card_response_types/generated_card_response_type";
+import { SourceTaxonomy } from "../types/source_taxonomy_type";
+import { ParsedCardType } from "../types/parsed_card_type";
+import { getPrompts } from "../services/get_prompts";
+import axios from "axios";
+import { jsonrepair } from "jsonrepair";
+
+// Type for the response structure returned by generateCardsForType
+type GenerateCardsResponse = {
+  status_code: number;
+  metadata: any;
+  type: string;
+  cards_data?: ParsedCardType[];
+};
+
+// Type for list/array of GenerateCardsResponse (including undefined)
+export type GenerateCardsResponseList = (GenerateCardsResponse | undefined)[];
+
+export class GenerateCards {
+  openAiService: OpenAiService;
+  public content: string;
+  public sourceId: string;
+  public taxonomy: SourceTaxonomy;
+  public source_type: string;
+  openAIHelper: OpenAIHelper;
+  public promptIdForCardsGeneration: string;
+  public generationCurriculum: boolean;
+  constructor(
+    openAiService: OpenAiService,
+    sourceId: string,
+    content: string,
+    taxonomy: SourceTaxonomy,
+
+    promptIdForCardsGeneration: string,
+    generationCurriculum: boolean,
+    source_type: string
+  ) {
+    this.openAiService = openAiService;
+    this.openAIHelper = new OpenAIHelper(this.openAiService.api_key);
+    this.sourceId = sourceId;
+    this.content = content;
+    this.taxonomy = taxonomy;
+    this.promptIdForCardsGeneration = promptIdForCardsGeneration;
+    this.generationCurriculum = generationCurriculum;
+    this.source_type = source_type;
+  }
+
+  async openAIResponse(card_generation_types: string[]) {
+    const variables = await getPrompts(this.source_type, card_generation_types);
+    const concepts = this.taxonomy.concepts_facts
+      .filter((concept) => concept.type === "concept")
+      .map((concept) => concept.text);
+    const facts = this.taxonomy.concepts_facts
+      .filter((fact) => fact.type === "fact")
+      .map((fact) => fact.text);
+    const schema = await buildCardSchema(
+      concepts,
+      facts,
+      card_generation_types
+    );
+    try {
+      let response: any = await this.openAIHelper.openAI.responses.create({
+        prompt: {
+          id: this.promptIdForCardsGeneration,
+          variables: {
+            bloom_level: "1",
+            card_types: card_generation_types.join(","),
+            bloom_instructions: variables.bloom_instructions,
+            card_instructions: variables.card_instructions,
+            card_examples: variables.card_examples,
+          },
+        },
+        max_output_tokens: 30000,
+
+        input: [
+          {
+            role: "user",
+            content: [{ type: "input_text", text: this.content }],
+          },
+        ],
+        store: true,
+        text: {
+          format: {
+            type: "json_schema",
+            name: schema.name,
+            strict: schema.strict,
+            schema: schema.schema,
+          },
+        },
+      });
+
+      if (!response) {
+        await log_error({
+          flow: this.generationCurriculum
+            ? "curriculum_manual_generation"
+            : "manual_generation",
+          data: JSON.stringify(response),
+          timestamp: new Date(),
+          error: "empty_openai_response",
+          source_id: this.sourceId,
+          type: {
+            request_type: "depth",
+            n: 1,
+          },
+        });
+        return;
+      }
+
+      return response;
+    } catch (error) {
+      if (error instanceof ParsingError) {
+        await log_error({
+          flow: this.generationCurriculum
+            ? "curriculum_manual_generation"
+            : "manual_generation",
+          data: error,
+          timestamp: new Date(),
+          error: "parsing_error",
+          source_id: this.sourceId,
+          type: {
+            request_type: "depth",
+            n: 1,
+            card_types: card_generation_types.join(","),
+          },
+        });
+      } else {
+        console.log(error);
+        await log_error({
+          flow: this.generationCurriculum
+            ? "curriculum_manual_generation"
+            : "manual_generation",
+          data: error,
+          timestamp: new Date(),
+          error: "error_in_card_generation",
+          source_id: this.sourceId,
+          type: {
+            request_type: "depth",
+            n: 1,
+            card_types: card_generation_types.join(","),
+          },
+        });
+      }
+    }
+  }
+
+  async generateCards(
+    n: number,
+    card_generation_types: string[]
+  ): Promise<GenerateCardsResponseList> {
+    try {
+      // Use Promise.allSettled to allow individual types to fail without affecting others
+      const settledResponses = await Promise.allSettled(
+        card_generation_types.map(async (card_generation_type) => {
+          return await this.generateCardsForType(n, card_generation_type);
+        })
+      );
+
+      // Extract fulfilled responses and log rejected ones
+      let responses: GenerateCardsResponseList = settledResponses
+        .map((result, index) => {
+          if (result.status === "fulfilled") {
+            if (result.value) {
+              return result.value;
+            } else {
+              // Log when fulfilled but value is undefined
+              console.error(
+                `Card generation for type ${card_generation_types[index]} returned undefined`
+              );
+              log_error({
+                flow: this.generationCurriculum
+                  ? "curriculum_manual_generation"
+                  : "manual_generation",
+                data: "Fulfilled promise returned undefined value",
+                timestamp: new Date(),
+                error: "undefined_value_in_card_generation",
+                source_id: this.sourceId,
+                type: {
+                  request_type: "depth",
+                  n: n,
+                  card_types: card_generation_types[index],
+                },
+              });
+              return undefined;
+            }
+          } else {
+            // Log the rejection but continue with other types
+            console.error(
+              `Failed to generate cards for type ${card_generation_types[index]}:`,
+              result.reason
+            );
+            log_error({
+              flow: this.generationCurriculum
+                ? "curriculum_manual_generation"
+                : "manual_generation",
+              data: result.reason,
+              timestamp: new Date(),
+              error: "error_in_card_generation_for_type",
+              source_id: this.sourceId,
+              type: {
+                request_type: "depth",
+                n: n,
+                card_types: card_generation_types[index],
+              },
+            });
+            return undefined;
+          }
+        })
+        .filter(
+          (response): response is GenerateCardsResponse =>
+            response !== undefined
+        );
+
+      // Flatten all parsed cards from all responses
+      // const allParsedCards: AllParsedCards = [];
+      // for (const response of responses) {
+      //   if (response && response.cards_data) {
+      //     allParsedCards.push(...response.cards_data);
+      //   }
+      // }
+
+      return responses;
+    } catch (e: any) {
+      await log_error({
+        flow: this.generationCurriculum
+          ? "curriculum_manual_generation"
+          : "manual_generation",
+        data: e,
+        timestamp: new Date(),
+        error: "error_in_card_generation",
+        source_id: this.sourceId,
+        type: {
+          request_type: "depth",
+          n: n,
+        },
+      });
+      return [];
+    }
+  }
+
+  async generateCardsForType(
+    n: number,
+    card_generation_type: string
+  ): Promise<GenerateCardsResponse | undefined> {
+    try {
+      let response = await this.openAIResponse([card_generation_type]);
+      response.metadata = {
+        req_time: response.generated_at ?? new Date(),
+        req_type: {
+          type: "depth",
+          n: n,
+          card_types: card_generation_type,
+          bloom_level: 1,
+        },
+        req_tokens: response.usage_data?.prompt_tokens,
+        res_tokens: response.usage_data?.completion_tokens,
+        prompt: {
+          id: response.prompt.id,
+          version: response.prompt.version,
+        },
+        prompt_tokens_details: response.usage_data?.prompt_tokens_details,
+        model: response.model,
+      };
+      if (response.status == "completed") {
+        response.metadata.status = "completed";
+        /// map response to generated_content
+
+        const testCardsArray = this.parseJson(response);
+        const generated_data: GeneratedCardResponseType = {
+          metadata: response.metadata,
+          generated_content: {
+            test_cards: testCardsArray.map((card: any) => {
+              return {
+                type: card.type,
+                card_content: card.card_content,
+                concepts: card.concepts ?? [],
+                facts: card.facts ?? [],
+                bloom_level: card.bloom_level ?? 1,
+                explanation: card.explanation ?? "",
+              };
+            }),
+          },
+          usage_data: response.usage,
+          generated_at: response.created_at,
+          status_code: response.status == "completed" ? 200 : 400,
+        };
+        let parseCard = new ParseCardResponse().parse(
+          generated_data,
+          this.taxonomy,
+          1
+        );
+        return parseCard;
+      } else {
+        response.metadata.status = "failed";
+        response.metadata.err_message = response.message;
+        return response;
+      }
+    } catch (e: any) {
+      await log_error({
+        flow: this.generationCurriculum
+          ? "curriculum_manual_generation"
+          : "manual_generation",
+        data: e,
+        timestamp: new Date(),
+        error: "error_in_card_generation",
+        source_id: this.sourceId,
+        type: {
+          request_type: "depth",
+          n: n,
+          card_types: card_generation_type,
+          bloom_level: 1,
+        },
+      });
+      return undefined;
+    }
+  }
+
+  parseJson(response: any) {
+    try {
+      const testCardsArray = JSON.parse(response.output_text).test_cards;
+      return testCardsArray;
+    } catch (e) {
+      // If original JSON parse fails, attempt to repair and parse
+      try {
+        const repairedJson = jsonrepair(response.output_text);
+        const parsedJson = JSON.parse(repairedJson);
+        if (parsedJson.test_cards) {
+          return parsedJson.test_cards;
+        }
+        throw new ParsingError(
+          "Something went wrong in parsing the json",
+          response
+        );
+      } catch (repairError) {
+        // If repair also fails, throw exception
+        throw new ParsingError(
+          "Something went wrong in repairing the json",
+          response
+        );
+      }
+    }
+  }
+}