@thanh01.pmt/interactive-quiz-kit 1.0.21 → 1.0.22

package/dist/ai.cjs

@@ -1,1449 +0,0 @@
-'use strict';
-
-var zod = require('zod');
-var genkit = require('genkit');
-var googleai = require('@genkit-ai/googleai');
-
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-
-// src/utils/idGenerators.ts
-function generateUniqueId(prefix = "id_") {
-  return prefix + Date.now().toString(36) + Math.random().toString(36).substring(2, 7);
-}
-
-// src/ai/flows/generate-fitb-question.ts
-function extractJsonFromMarkdown(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-zod.z.object({
-  topic: zod.z.string().describe("The topic for the question."),
-  language: zod.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfBlanks: zod.z.number().int().min(1).max(5).optional().default(1).describe("Number of blanks to include (1-5)."),
-  isCaseSensitive: zod.z.boolean().optional().default(false).describe("Whether answers should be case-sensitive."),
-  contextDescription: zod.z.string().optional().describe("A specific context or scenario for the question."),
-  selectedContextId: zod.z.string().optional().describe("The ID of the selected context.")
-});
-zod.z.object({
-  prompt: zod.z.string().describe("The overall instruction for the question."),
-  sentenceWithPlaceholders: zod.z.string().describe("The sentence containing placeholders like {{placeholder_name}}."),
-  blanks: zod.z.array(
-    zod.z.object({
-      placeholder: zod.z.string().describe("The placeholder name (without curly braces)."),
-      acceptedAnswers: zod.z.array(zod.z.string().min(1)).min(1).describe("Array of acceptable answers.")
-    })
-  ).min(1),
-  isCaseSensitive: zod.z.boolean().optional(),
-  explanation: zod.z.string().optional(),
-  points: zod.z.number().optional().default(10),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: zod.z.string().optional()
-});
-var FillInTheBlanksQuestionZodSchema = zod.z.object({
-  id: zod.z.string(),
-  questionType: zod.z.literal("fill_in_the_blanks"),
-  prompt: zod.z.string().min(1),
-  segments: zod.z.array(zod.z.object({
-    type: zod.z.enum(["text", "blank"]),
-    content: zod.z.string().optional(),
-    // Only for 'text' type
-    id: zod.z.string().optional()
-    // Only for 'blank' type
-  })).min(1),
-  answers: zod.z.array(zod.z.object({
-    blankId: zod.z.string(),
-    acceptedValues: zod.z.array(zod.z.string().min(1)).min(1)
-  })).min(1),
-  isCaseSensitive: zod.z.boolean().optional(),
-  points: zod.z.number().min(0).optional(),
-  explanation: zod.z.string().optional()
-  // ... other fields
-}).refine((data) => {
-  const segmentBlankIds = new Set(data.segments.filter((s) => s.type === "blank").map((s) => s.id));
-  const answerBlankIds = new Set(data.answers.map((a) => a.blankId));
-  if (segmentBlankIds.size !== answerBlankIds.size) return false;
-  for (const id of segmentBlankIds) {
-    if (!answerBlankIds.has(id || "")) return false;
-  }
-  return true;
-}, {
-  message: "There must be a 1-to-1 correspondence between blank segments and answer definitions.",
-  path: ["answers"]
-});
-zod.z.object({
-  question: FillInTheBlanksQuestionZodSchema.optional().describe("The generated question.")
-});
-async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
-  var _a;
-  try {
-    const ai = genkit.genkit({
-      plugins: [googleai.googleAI({ apiKey })],
-      model: googleai.gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer.
-Generate a single Fill-In-The-Blanks question in ${clientInput.language} with approximately ${clientInput.numberOfBlanks} blank(s).
-
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "Complete the famous saying.",
-  "sentenceWithPlaceholders": "Roses are {{color1}}, violets are {{color2}}.",
-  "blanks": [
-    { "placeholder": "color1", "acceptedAnswers": ["red"] },
-    { "placeholder": "color2", "acceptedAnswers": ["blue"] }
-  ],
-  "isCaseSensitive": false,
-  "explanation": "This is a classic nursery rhyme.",
-  "points": 10,
-  "difficulty": "easy",
-  "topic": "Nursery Rhymes"
-}
-
-Requirements:
-- Use double curly braces for placeholders, like {{placeholder_name}}.
-- Each placeholder name inside the braces must be unique.
-- The 'blanks' array must define the accepted answers for every unique placeholder in the sentence.
-- The 'placeholder' value in the 'blanks' array should NOT include the curly braces.
-- The content of 'prompt', 'sentenceWithPlaceholders', 'blanks.acceptedAnswers', 'explanation', and 'topic' must be in ${clientInput.language}.
-
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-Difficulty: ${clientInput.difficulty}
-Target Number of Blanks: ${clientInput.numberOfBlanks}
-Case Sensitive: ${clientInput.isCaseSensitive}
-
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown(rawText);
-    console.log("AI Response:", jsonText);
-    const aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent) {
-      const segments = [];
-      const answers = [];
-      const placeholderToBlankIdMap = {};
-      aiGeneratedContent.blanks.forEach((blankInfo) => {
-        const blankId = generateUniqueId("blank_");
-        placeholderToBlankIdMap[blankInfo.placeholder] = blankId;
-        answers.push({
-          blankId,
-          acceptedValues: blankInfo.acceptedAnswers
-        });
-      });
-      const placeholderRegex = /\{\{([^}]+)\}\}/g;
-      let lastIndex = 0;
-      let match;
-      while ((match = placeholderRegex.exec(aiGeneratedContent.sentenceWithPlaceholders)) !== null) {
-        const placeholderName = match[1];
-        const blankId = placeholderToBlankIdMap[placeholderName];
-        if (match.index > lastIndex) {
-          segments.push({ type: "text", content: aiGeneratedContent.sentenceWithPlaceholders.substring(lastIndex, match.index) });
-        }
-        if (blankId) {
-          segments.push({ type: "blank", id: blankId });
-        } else {
-          console.warn(`Placeholder {{${placeholderName}}} found in sentence but not defined in blanks array. Treating as literal text.`);
-          segments.push({ type: "text", content: match[0] });
-        }
-        lastIndex = placeholderRegex.lastIndex;
-      }
-      if (lastIndex < aiGeneratedContent.sentenceWithPlaceholders.length) {
-        segments.push({ type: "text", content: aiGeneratedContent.sentenceWithPlaceholders.substring(lastIndex) });
-      }
-      const completeQuestion = {
-        id: generateUniqueId("fitb_ai_"),
-        questionType: "fill_in_the_blanks",
-        prompt: aiGeneratedContent.prompt,
-        segments,
-        answers,
-        isCaseSensitive: (_a = aiGeneratedContent.isCaseSensitive) != null ? _a : clientInput.isCaseSensitive,
-        explanation: aiGeneratedContent.explanation,
-        points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
-      };
-      try {
-        const validatedQuestion = FillInTheBlanksQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
-      }
-    } else {
-      throw new Error("AI did not return content for the Fill-In-The-Blanks question.");
-    }
-  } catch (error) {
-    console.error("Error generating Fill-In-The-Blanks question:", error);
-    throw new Error(`Failed to generate Fill-In-The-Blanks question: ${error.message}`);
-  }
-}
-function extractJsonFromMarkdown2(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-zod.z.object({
-  topic: zod.z.string().describe("The topic for the question."),
-  language: zod.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfPairs: zod.z.number().int().min(2).max(8).optional().default(4).describe("Number of pairs to match (2-8)."),
-  shuffleOptions: zod.z.boolean().optional().default(true).describe("Whether the options should be shuffled."),
-  contextDescription: zod.z.string().optional().describe("A specific context or scenario for the question."),
-  selectedContextId: zod.z.string().optional().describe("The ID of the selected context.")
-});
-zod.z.object({
-  prompt: zod.z.string().describe("The overall instruction (e.g., 'Match the terms to their definitions.')."),
-  correctPairs: zod.z.array(
-    zod.z.object({
-      promptText: zod.z.string().min(1).describe("The text for a prompt item (e.g., a term)."),
-      optionText: zod.z.string().min(1).describe("The text for the corresponding option item (e.g., its definition).")
-    })
-  ).min(2),
-  explanation: zod.z.string().optional(),
-  points: zod.z.number().optional().default(10),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: zod.z.string().optional()
-});
-var MatchingQuestionZodSchema = zod.z.object({
-  id: zod.z.string(),
-  questionType: zod.z.literal("matching"),
-  prompt: zod.z.string().min(1),
-  prompts: zod.z.array(zod.z.object({ id: zod.z.string(), content: zod.z.string().min(1) })).min(2),
-  options: zod.z.array(zod.z.object({ id: zod.z.string(), content: zod.z.string().min(1) })).min(2),
-  correctAnswerMap: zod.z.array(zod.z.object({ promptId: zod.z.string(), optionId: zod.z.string() })).min(2),
-  shuffleOptions: zod.z.boolean().optional(),
-  points: zod.z.number().min(0).optional(),
-  explanation: zod.z.string().optional()
-  // ... other fields
-}).refine((data) => {
-  const promptIds = new Set(data.prompts.map((p) => p.id));
-  const optionIds = new Set(data.options.map((o) => o.id));
-  return data.correctAnswerMap.every(
-    (map) => promptIds.has(map.promptId) && optionIds.has(map.optionId)
-  );
-}, {
-  message: "All IDs in correctAnswerMap must exist in the prompts and options arrays.",
-  path: ["correctAnswerMap"]
-}).refine((data) => {
-  const mappedPromptIds = new Set(data.correctAnswerMap.map((m) => m.promptId));
-  return mappedPromptIds.size === data.prompts.length && data.correctAnswerMap.length === data.prompts.length;
-}, {
-  message: "Each prompt must be mapped exactly once in the correctAnswerMap.",
-  path: ["correctAnswerMap"]
-});
-zod.z.object({
-  question: MatchingQuestionZodSchema.optional().describe("The generated Matching question.")
-});
-async function generateMatchingQuestion(clientInput, apiKey) {
-  try {
-    const ai = genkit.genkit({
-      plugins: [googleai.googleAI({ apiKey })],
-      model: googleai.gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer.
-Generate a single Matching question in ${clientInput.language} with exactly ${clientInput.numberOfPairs} correct pairs.
-
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "Match each country to its capital city.",
-  "correctPairs": [
-    { "promptText": "France", "optionText": "Paris" },
-    { "promptText": "Japan", "optionText": "Tokyo" },
-    { "promptText": "Egypt", "optionText": "Cairo" },
-    { "promptText": "Brazil", "optionText": "Bras\xEDlia" }
-  ],
-  "explanation": "These are the capital cities for the respective countries.",
-  "points": 10,
-  "difficulty": "medium",
-  "topic": "World Geography"
-}
-
-Requirements:
-- The 'correctPairs' array must contain exactly ${clientInput.numberOfPairs} objects.
-- Each object in 'correctPairs' must have a 'promptText' and its corresponding 'optionText'.
-- Ensure the content of all 'promptText' values are unique.
-- Ensure the content of all 'optionText' values are unique.
-- The content of 'prompt', 'correctPairs.promptText', 'correctPairs.optionText', 'explanation', and 'topic' must be in ${clientInput.language}.
-
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-Difficulty: ${clientInput.difficulty}
-Number of Pairs: ${clientInput.numberOfPairs}
-
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown2(rawText);
-    console.log("AI Response:", jsonText);
-    const aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent) {
-      if (aiGeneratedContent.correctPairs.length !== clientInput.numberOfPairs) {
-        throw new Error(`AI generated ${aiGeneratedContent.correctPairs.length} pairs, but ${clientInput.numberOfPairs} were requested.`);
-      }
-      const finalPrompts = [];
-      const finalOptions = [];
-      const finalCorrectAnswerMap = [];
-      aiGeneratedContent.correctPairs.forEach((pair) => {
-        const promptId = generateUniqueId("m_p_");
-        const optionId = generateUniqueId("m_o_");
-        finalPrompts.push({ id: promptId, content: pair.promptText });
-        finalOptions.push({ id: optionId, content: pair.optionText });
-        finalCorrectAnswerMap.push({ promptId, optionId });
-      });
-      const completeQuestion = {
-        id: generateUniqueId("match_ai_"),
-        questionType: "matching",
-        prompt: aiGeneratedContent.prompt,
-        prompts: finalPrompts,
-        options: finalOptions,
-        correctAnswerMap: finalCorrectAnswerMap,
-        shuffleOptions: clientInput.shuffleOptions,
-        explanation: aiGeneratedContent.explanation,
-        points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
-      };
-      try {
-        const validatedQuestion = MatchingQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
-      }
-    } else {
-      throw new Error("AI did not return content for the Matching question.");
-    }
-  } catch (error) {
-    console.error("Error generating Matching question:", error);
-    throw new Error(`Failed to generate Matching question: ${error.message}`);
-  }
-}
-function extractJsonFromMarkdown3(text) {
-  return text.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
-}
-zod.z.object({
-  topic: zod.z.string().describe("The topic for the question."),
-  language: zod.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfOptions: zod.z.number().int().min(2).max(6).optional().default(4).describe("Number of answer options to generate (2-6)."),
-  contextDescription: zod.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: zod.z.string().optional().describe("The ID of the selected context, if any.")
-});
-zod.z.object({
-  prompt: zod.z.string().describe("The question statement itself."),
-  options: zod.z.array(
-    zod.z.object({
-      tempId: zod.z.string().describe("A temporary, unique identifier for this option (e.g., 'A', 'B', '1', '2')."),
-      text: zod.z.string().describe("The text content of this answer option.")
-    })
-  ).min(2).max(6),
-  correctTempOptionId: zod.z.string().describe("The temporary ID of the correct option from the generated options array."),
-  explanation: zod.z.string().optional().describe("A brief explanation of why the answer is correct."),
-  points: zod.z.number().optional().default(10).describe("Points for a correct answer."),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional().describe("Assessed difficulty."),
-  topic: zod.z.string().optional().describe("Refined topic.")
-});
-var MultipleChoiceQuestionZodSchema = zod.z.object({
-  id: zod.z.string(),
-  questionType: zod.z.literal("multiple_choice"),
-  prompt: zod.z.string().min(1),
-  options: zod.z.array(zod.z.object({ id: zod.z.string(), text: zod.z.string().min(1) })).min(2).max(10),
-  correctAnswerId: zod.z.string(),
-  points: zod.z.number().min(0).optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
-}).refine((data) => {
-  return data.options.some((option) => option.id === data.correctAnswerId);
-}, {
-  message: "correctAnswerId must match one of the option IDs",
-  path: ["correctAnswerId"]
-}).refine((data) => {
-  const optionIds = data.options.map((opt) => opt.id);
-  return optionIds.length === new Set(optionIds).size;
-}, {
-  message: "All option IDs must be unique",
-  path: ["options"]
-});
-zod.z.object({
-  question: MultipleChoiceQuestionZodSchema.optional().describe("The generated Multiple Choice question.")
-});
-async function generateMCQQuestion(clientInput, apiKey) {
-  try {
-    const ai = genkit.genkit({
-      plugins: [googleai.googleAI({ apiKey })],
-      model: googleai.gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer.
-Generate a single Multiple Choice question in ${clientInput.language} based on the following inputs.
-
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "Your question here",
-  "options": [
-    { "tempId": "A", "text": "First option text" },
-    { "tempId": "B", "text": "Second option text" },
-    { "tempId": "C", "text": "Third option text" },
-    { "tempId": "D", "text": "Fourth option text" }
-  ],
-  "correctTempOptionId": "C",
-  "explanation": "Brief explanation",
-  "points": 10,
-  "difficulty": "medium",
-  "topic": "refined topic"
-}
-
-Requirements:
-- Generate exactly ${clientInput.numberOfOptions} options.
-- Use tempId values like "A", "B", "C", "D" or "option_1", "option_2", etc.
-- Make sure correctTempOptionId matches one of the tempId values in options array.
-- Each option must have both "tempId" and "text" fields.
-- The content of 'prompt', 'options.text', 'explanation', and 'topic' must be in ${clientInput.language}.
-
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-${clientInput.contextDescription ? `Context: ${clientInput.contextDescription}` : ""}
-Difficulty: ${clientInput.difficulty}
-Number of Options: ${clientInput.numberOfOptions}
-
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown3(rawText);
-    console.log("AI Response:", jsonText);
-    let aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent.options && Array.isArray(aiGeneratedContent.options)) {
-      const normalizedOptions = aiGeneratedContent.options.map((option, index) => {
-        if (typeof option === "object" && !option.tempId) {
-          const key = Object.keys(option)[0];
-          const text = option[key];
-          return { tempId: key, text };
-        }
-        return option;
-      });
-      aiGeneratedContent.options = normalizedOptions;
-    }
-    console.log("Normalized AI Content:", JSON.stringify(aiGeneratedContent, null, 2));
-    if (aiGeneratedContent) {
-      const finalOptions = [];
-      const tempIdToFinalIdMap = {};
-      aiGeneratedContent.options.forEach((aiOption) => {
-        const finalId = generateUniqueId("opt_");
-        finalOptions.push({ id: finalId, text: aiOption.text });
-        tempIdToFinalIdMap[aiOption.tempId] = finalId;
-      });
-      const finalCorrectAnswerId = tempIdToFinalIdMap[aiGeneratedContent.correctTempOptionId];
-      if (!finalCorrectAnswerId) {
-        throw new Error(`Correct option ID '${aiGeneratedContent.correctTempOptionId}' is invalid or does not match any generated option tempId.`);
-      }
-      const completeQuestion = {
-        id: generateUniqueId("mcq_ai_"),
-        questionType: "multiple_choice",
-        prompt: aiGeneratedContent.prompt,
-        options: finalOptions,
-        correctAnswerId: finalCorrectAnswerId,
-        explanation: aiGeneratedContent.explanation,
-        points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
-      };
-      try {
-        const validatedQuestion = MultipleChoiceQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
-      }
-    } else {
-      throw new Error("AI did not return content for the MCQ question.");
-    }
-  } catch (error) {
-    console.error("Error generating MCQ question:", error);
-    throw new Error(`Failed to generate MCQ question: ${error.message}`);
-  }
-}
-function extractJsonFromMarkdown4(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-zod.z.object({
-  topic: zod.z.string().describe("The topic for the question."),
-  language: zod.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfOptions: zod.z.number().int().min(2).max(8).optional().default(5).describe("Number of answer options to generate (2-8)."),
-  minCorrectAnswers: zod.z.number().int().min(1).optional().default(2).describe("Minimum number of correct answers among the options."),
-  maxCorrectAnswers: zod.z.number().int().min(1).optional().default(3).describe("Maximum number of correct answers (must be <= numberOfOptions)."),
-  contextDescription: zod.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: zod.z.string().optional().describe("The ID of the selected context, if any.")
-});
-zod.z.object({
-  prompt: zod.z.string().describe("The question statement itself."),
-  options: zod.z.array(
-    zod.z.object({
-      tempId: zod.z.string().describe("A temporary, unique identifier for this option (e.g., 'A', 'B')."),
-      text: zod.z.string().describe("The text content of this answer option.")
-    })
-  ).min(2).max(8),
-  correctTempOptionIds: zod.z.array(zod.z.string()).min(1).describe("An array of temporary IDs of the correct options."),
-  explanation: zod.z.string().optional().describe("A brief explanation of why the answers are correct."),
-  points: zod.z.number().optional().default(10).describe("Points for a correct answer."),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional().describe("Assessed difficulty."),
-  topic: zod.z.string().optional().describe("Refined topic.")
-});
-var MultipleResponseQuestionZodSchema = zod.z.object({
-  id: zod.z.string(),
-  questionType: zod.z.literal("multiple_response"),
-  prompt: zod.z.string().min(1),
-  options: zod.z.array(zod.z.object({ id: zod.z.string(), text: zod.z.string().min(1) })).min(2).max(10),
-  correctAnswerIds: zod.z.array(zod.z.string()).min(1),
-  points: zod.z.number().min(0).optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
-}).refine((data) => {
-  const optionIds = new Set(data.options.map((option) => option.id));
-  return data.correctAnswerIds.every((correctId) => optionIds.has(correctId));
-}, {
-  message: "All correctAnswerIds must match one of the option IDs",
-  path: ["correctAnswerIds"]
-}).refine((data) => {
-  const optionIds = data.options.map((opt) => opt.id);
-  return optionIds.length === new Set(optionIds).size;
-}, {
-  message: "All option IDs must be unique",
-  path: ["options"]
-});
-zod.z.object({
-  question: MultipleResponseQuestionZodSchema.optional().describe("The generated Multiple Response question.")
-});
-async function generateMRQQuestion(clientInput, apiKey) {
-  try {
-    if (clientInput.minCorrectAnswers > clientInput.maxCorrectAnswers) {
-      throw new Error("Minimum correct answers cannot exceed maximum correct answers.");
-    }
-    if (clientInput.maxCorrectAnswers >= clientInput.numberOfOptions) {
-      throw new Error("Maximum correct answers must be less than the total number of options.");
-    }
-    const ai = genkit.genkit({
-      plugins: [googleai.googleAI({ apiKey })],
-      model: googleai.gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer specializing in Multiple Response questions.
-Generate a single Multiple Response question in ${clientInput.language} based on the following inputs.
-
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "Your question here (e.g., 'Which of the following are primary colors?')",
-  "options": [
-    { "tempId": "A", "text": "First option" },
-    { "tempId": "B", "text": "Second option" },
-    { "tempId": "C", "text": "Third option" },
-    { "tempId": "D", "text": "Fourth option" },
-    { "tempId": "E", "text": "Fifth option" }
-  ],
-  "correctTempOptionIds": ["A", "C"],
-  "explanation": "Brief explanation of all correct answers.",
-  "points": 10,
-  "difficulty": "medium",
-  "topic": "refined topic"
-}
-
-Requirements:
-- Generate exactly ${clientInput.numberOfOptions} options.
-- Generate between ${clientInput.minCorrectAnswers} and ${clientInput.maxCorrectAnswers} correct answers.
-- Use tempId values like "A", "B", "C", etc.
-- Make sure all IDs in correctTempOptionIds match a tempId in the options array.
-- Each option must have both "tempId" and "text" fields.
-- The content of 'prompt', 'options.text', 'explanation', and 'topic' must be in ${clientInput.language}.
-
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-${clientInput.contextDescription ? `Context: ${clientInput.contextDescription}` : ""}
-Difficulty: ${clientInput.difficulty}
-Number of Options: ${clientInput.numberOfOptions}
-Min Correct Answers: ${clientInput.minCorrectAnswers}
-Max Correct Answers: ${clientInput.maxCorrectAnswers}
-
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown4(rawText);
-    console.log("AI Response:", jsonText);
-    let aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent.options && Array.isArray(aiGeneratedContent.options)) {
-      const normalizedOptions = aiGeneratedContent.options.map((option) => {
-        if (typeof option === "object" && !option.tempId && Object.keys(option).length === 1) {
-          const key = Object.keys(option)[0];
-          return { tempId: key, text: option[key] };
-        }
-        return option;
-      });
-      aiGeneratedContent.options = normalizedOptions;
-    }
-    console.log("Normalized AI Content:", JSON.stringify(aiGeneratedContent, null, 2));
-    if (aiGeneratedContent) {
-      const finalOptions = [];
-      const tempIdToFinalIdMap = {};
-      aiGeneratedContent.options.forEach((aiOption) => {
-        const finalId = generateUniqueId("opt_mr_");
-        finalOptions.push({ id: finalId, text: aiOption.text });
-        tempIdToFinalIdMap[aiOption.tempId] = finalId;
-      });
-      const finalCorrectAnswerIds = aiGeneratedContent.correctTempOptionIds.map((tempId) => {
-        const finalId = tempIdToFinalIdMap[tempId];
-        if (!finalId) {
-          throw new Error(`AI provided an invalid correctTempOptionId ('${tempId}') that does not map to any generated option.`);
-        }
-        return finalId;
-      });
-      if (finalCorrectAnswerIds.length < clientInput.minCorrectAnswers || finalCorrectAnswerIds.length > clientInput.maxCorrectAnswers) {
-        throw new Error(`AI generated ${finalCorrectAnswerIds.length} correct answers, which is outside the requested range of ${clientInput.minCorrectAnswers}-${clientInput.maxCorrectAnswers}.`);
-      }
-      if (finalOptions.length !== clientInput.numberOfOptions) {
-        throw new Error(`AI generated ${finalOptions.length} options, but ${clientInput.numberOfOptions} were requested.`);
-      }
-      const completeQuestion = {
-        id: generateUniqueId("mrq_ai_"),
-        questionType: "multiple_response",
-        prompt: aiGeneratedContent.prompt,
-        options: finalOptions,
-        correctAnswerIds: finalCorrectAnswerIds,
-        explanation: aiGeneratedContent.explanation,
-        points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
-      };
-      try {
-        const validatedQuestion = MultipleResponseQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
-      }
-    } else {
-      throw new Error("AI did not return content for the MRQ question.");
-    }
-  } catch (error) {
-    console.error("Error generating MRQ question:", error);
-    throw new Error(`Failed to generate MRQ question: ${error.message}`);
-  }
-}
-function extractJsonFromMarkdown5(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-zod.z.object({
-  topic: zod.z.string().describe("The topic for the question."),
-  language: zod.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  allowDecimals: zod.z.boolean().optional().default(true).describe("Whether the answer can be a decimal."),
-  minRange: zod.z.number().optional().describe("Optional minimum value for the answer."),
-  maxRange: zod.z.number().optional().describe("Optional maximum value for the answer."),
-  contextDescription: zod.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: zod.z.string().optional().describe("The ID of the selected context, if any.")
-});
-zod.z.object({
-  prompt: zod.z.string().describe("The question statement that expects a numerical answer."),
-  answer: zod.z.number().describe("The precise numerical correct answer."),
-  tolerance: zod.z.number().min(0).optional().default(0).describe("The acceptable range of error (plus or minus). Default is 0 for exact match."),
-  explanation: zod.z.string().optional().describe("Explanation for the correct answer."),
-  points: zod.z.number().optional().default(10),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: zod.z.string().optional()
-});
-var NumericQuestionZodSchema = zod.z.object({
-  id: zod.z.string(),
-  questionType: zod.z.literal("numeric"),
-  prompt: zod.z.string().min(1),
-  answer: zod.z.number(),
-  tolerance: zod.z.number().min(0).optional(),
-  points: zod.z.number().min(0).optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
-});
-zod.z.object({
-  question: NumericQuestionZodSchema.optional().describe("The generated Numeric question.")
-});
-async function generateNumericQuestion(clientInput, apiKey) {
-  try {
-    if (clientInput.minRange !== void 0 && clientInput.maxRange !== void 0 && clientInput.minRange > clientInput.maxRange) {
-      throw new Error("minRange cannot be greater than maxRange.");
-    }
-    const ai = genkit.genkit({
-      plugins: [googleai.googleAI({ apiKey })],
-      model: googleai.gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer.
-Generate a single Numeric question in ${clientInput.language} based on the following inputs. The question must require a numerical answer.
-
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "Your question here (e.g., 'What is the value of Pi rounded to two decimal places?')",
-  "answer": 3.14,
-  "tolerance": 0.01,
-  "explanation": "Pi is an irrational number, approximately 3.14159. Rounding to two decimal places gives 3.14.",
-  "points": 10,
-  "difficulty": "easy",
-  "topic": "Mathematics"
-}
-
-Requirements:
-- The 'answer' must be a number.
-- If 'allowDecimals' is false, the 'answer' must be an integer.
-- 'tolerance' is the acceptable error range (+/-). A tolerance of 0 means the answer must be exact.
-- The content of 'prompt', 'explanation', and 'topic' must be in ${clientInput.language}.
-${clientInput.minRange !== void 0 ? `- The answer should ideally be >= ${clientInput.minRange}.` : ""}
-${clientInput.maxRange !== void 0 ? `- The answer should ideally be <= ${clientInput.maxRange}.` : ""}
-
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-${clientInput.contextDescription ? `Context: ${clientInput.contextDescription}` : ""}
-Difficulty: ${clientInput.difficulty}
-Allow Decimals: ${clientInput.allowDecimals}
-
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown5(rawText);
-    console.log("AI Response:", jsonText);
-    const aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent) {
-      let finalAnswer = aiGeneratedContent.answer;
-      if (!clientInput.allowDecimals) {
-        finalAnswer = Math.round(finalAnswer);
-      }
-      if (clientInput.minRange !== void 0 && finalAnswer < clientInput.minRange) {
-        console.warn(`AI generated answer ${finalAnswer} is below the requested minRange of ${clientInput.minRange}.`);
-      }
-      if (clientInput.maxRange !== void 0 && finalAnswer > clientInput.maxRange) {
-        console.warn(`AI generated answer ${finalAnswer} is above the requested maxRange of ${clientInput.maxRange}.`);
-      }
-      const completeQuestion = {
-        id: generateUniqueId("num_ai_"),
-        questionType: "numeric",
-        prompt: aiGeneratedContent.prompt,
-        answer: finalAnswer,
-        tolerance: aiGeneratedContent.tolerance,
-        explanation: aiGeneratedContent.explanation,
-        points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
-      };
-      try {
-        const validatedQuestion = NumericQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
-      }
-    } else {
-      throw new Error("AI did not return content for the Numeric question.");
-    }
-  } catch (error) {
-    console.error("Error generating Numeric question:", error);
-    throw new Error(`Failed to generate Numeric question: ${error.message}`);
-  }
-}
-function extractJsonFromMarkdown6(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-zod.z.object({
-  topic: zod.z.string().describe("The topic for the question."),
-  language: zod.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfItems: zod.z.number().int().min(2).max(10).optional().default(4).describe("Number of items to sequence (2-10)."),
-  contextDescription: zod.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: zod.z.string().optional().describe("The ID of the selected context, if any.")
-});
-zod.z.object({
-  prompt: zod.z.string().describe("The instruction for sequencing."),
-  itemsContent: zod.z.array(zod.z.string().min(1)).min(2).describe("An array of strings for each item to be sequenced."),
-  correctOrderContent: zod.z.array(zod.z.string().min(1)).min(2).describe("An array of the same strings from 'itemsContent', but in the correct sequence."),
-  explanation: zod.z.string().optional().describe("Explanation for the correct sequence."),
-  points: zod.z.number().optional().default(10),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: zod.z.string().optional()
-});
-var SequenceQuestionZodSchema = zod.z.object({
-  id: zod.z.string(),
-  questionType: zod.z.literal("sequence"),
-  prompt: zod.z.string().min(1),
-  items: zod.z.array(zod.z.object({ id: zod.z.string(), content: zod.z.string().min(1) })).min(2),
-  correctOrder: zod.z.array(zod.z.string()).min(2),
-  // Array of item IDs
-  points: zod.z.number().min(0).optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
-}).refine((data) => {
-  const itemIds = new Set(data.items.map((item) => item.id));
-  return data.correctOrder.every((id) => itemIds.has(id));
-}, {
-  message: "Every ID in correctOrder must correspond to an item in the items array.",
-  path: ["correctOrder"]
-}).refine((data) => {
-  return new Set(data.correctOrder).size === data.items.length && data.correctOrder.length === data.items.length;
-}, {
-  message: "The correctOrder array must contain all item IDs exactly once.",
-  path: ["correctOrder"]
-}).refine((data) => {
-  const itemIds = data.items.map((item) => item.id);
-  return itemIds.length === new Set(itemIds).size;
-}, {
-  message: "All item IDs must be unique.",
-  path: ["items"]
-});
-zod.z.object({
-  question: SequenceQuestionZodSchema.optional().describe("The generated Sequence question.")
-});
-async function generateSequenceQuestion(clientInput, apiKey) {
-  try {
-    const ai = genkit.genkit({
-      plugins: [googleai.googleAI({ apiKey })],
-      model: googleai.gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer specializing in Sequence questions.
-Generate a single Sequence question in ${clientInput.language} based on the following inputs.
-
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "Arrange the following events of World War II in chronological order.",
-  "itemsContent": [
-    "D-Day (Normandy Landings)",
-    "Invasion of Poland",
-    "Attack on Pearl Harbor",
-    "Battle of Stalingrad"
-  ],
-  "correctOrderContent": [
-    "Invasion of Poland",
-    "Attack on Pearl Harbor",
-    "Battle of Stalingrad",
-    "D-Day (Normandy Landings)"
-  ],
-  "explanation": "The Invasion of Poland started the war in Europe, followed by the US entry after Pearl Harbor, the turning point at Stalingrad, and finally the D-Day invasion.",
-  "points": 10,
-  "difficulty": "medium",
-  "topic": "World War II History"
-}
-
-Requirements:
-- Generate exactly ${clientInput.numberOfItems} items to be sequenced.
-- The 'itemsContent' array should contain the text for each item.
-- The 'correctOrderContent' array must contain the exact same strings as 'itemsContent', but arranged in the correct sequence.
-- Both arrays must have the same number of elements.
-- The content of 'prompt', 'itemsContent', 'correctOrderContent', 'explanation', and 'topic' must be in ${clientInput.language}.
-
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-${clientInput.contextDescription ? `Context: ${clientInput.contextDescription}` : ""}
-Difficulty: ${clientInput.difficulty}
-Number of Items: ${clientInput.numberOfItems}
-
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown6(rawText);
-    console.log("AI Response:", jsonText);
-    const aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent) {
-      if (aiGeneratedContent.itemsContent.length !== clientInput.numberOfItems || aiGeneratedContent.correctOrderContent.length !== clientInput.numberOfItems) {
-        throw new Error(`AI generated an incorrect number of items. Requested: ${clientInput.numberOfItems}, Got: ${aiGeneratedContent.itemsContent.length} items and ${aiGeneratedContent.correctOrderContent.length} in correct order.`);
-      }
-      if (new Set(aiGeneratedContent.itemsContent).size !== new Set(aiGeneratedContent.correctOrderContent).size) {
-        throw new Error("The set of items in 'itemsContent' and 'correctOrderContent' do not match.");
-      }
-      const contentToIdMap = {};
-      const finalItems = aiGeneratedContent.itemsContent.map((content) => {
-        const id = generateUniqueId("seqi_");
-        contentToIdMap[content] = id;
-        return { id, content };
-      });
-      const finalCorrectOrder = aiGeneratedContent.correctOrderContent.map((content) => {
-        const id = contentToIdMap[content];
-        if (!id) {
-          throw new Error(`Content "${content}" from 'correctOrderContent' was not found in 'itemsContent'.`);
-        }
-        return id;
-      });
-      const completeQuestion = {
-        id: generateUniqueId("seq_ai_"),
-        questionType: "sequence",
-        prompt: aiGeneratedContent.prompt,
-        items: finalItems,
-        correctOrder: finalCorrectOrder,
-        explanation: aiGeneratedContent.explanation,
-        points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
-      };
-      try {
-        const validatedQuestion = SequenceQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
-      }
-    } else {
-      throw new Error("AI did not return content for the Sequence question.");
-    }
-  } catch (error) {
-    console.error("Error generating Sequence question:", error);
-    throw new Error(`Failed to generate Sequence question: ${error.message}`);
-  }
-}
-function extractJsonFromMarkdown7(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-zod.z.object({
-  topic: zod.z.string().describe("The topic for the question."),
-  language: zod.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  isCaseSensitive: zod.z.boolean().optional().default(false).describe("Whether the answer should be case-sensitive."),
-  contextDescription: zod.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: zod.z.string().optional().describe("The ID of the selected context, if any.")
-});
-zod.z.object({
-  prompt: zod.z.string().describe("The question statement."),
-  acceptedAnswers: zod.z.array(zod.z.string().min(1)).min(1).describe("An array of acceptable short answers."),
-  isCaseSensitive: zod.z.boolean().optional().describe("Should the answer evaluation be case sensitive?"),
-  explanation: zod.z.string().optional().describe("Explanation for the correct answer(s)."),
-  points: zod.z.number().optional().default(10),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: zod.z.string().optional()
-});
-var ShortAnswerQuestionZodSchema = zod.z.object({
-  id: zod.z.string(),
-  questionType: zod.z.literal("short_answer"),
-  prompt: zod.z.string().min(1),
-  acceptedAnswers: zod.z.array(zod.z.string().min(1)).min(1),
-  isCaseSensitive: zod.z.boolean().optional(),
-  points: zod.z.number().min(0).optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
-});
-zod.z.object({
-  question: ShortAnswerQuestionZodSchema.optional().describe("The generated Short Answer question.")
-});
-async function generateShortAnswerQuestion(clientInput, apiKey) {
-  var _a;
-  try {
-    const ai = genkit.genkit({
-      plugins: [googleai.googleAI({ apiKey })],
-      model: googleai.gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer.
-Generate a single Short Answer question in ${clientInput.language} based on the following inputs.
-
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "What is the capital of France?",
-  "acceptedAnswers": ["Paris"],
-  "isCaseSensitive": false,
-  "explanation": "Paris has been the capital of France since the 10th century.",
-  "points": 5,
-  "difficulty": "easy",
-  "topic": "World Capitals"
-}
-
-Requirements:
-- The 'acceptedAnswers' array must contain at least one possible correct answer.
-- If there are multiple common ways to phrase the answer (e.g., "USA", "United States"), include them in the array.
-- Set 'isCaseSensitive' to true or false based on the nature of the answer. Default to the input value.
-- The content of 'prompt', 'acceptedAnswers', 'explanation', and 'topic' must be in ${clientInput.language}.
-
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-${clientInput.contextDescription ? `Context: ${clientInput.contextDescription}` : ""}
-Difficulty: ${clientInput.difficulty}
-Case Sensitive: ${clientInput.isCaseSensitive}
-
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown7(rawText);
-    console.log("AI Response:", jsonText);
-    const aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent) {
-      const completeQuestion = {
-        id: generateUniqueId("saq_ai_"),
-        questionType: "short_answer",
-        prompt: aiGeneratedContent.prompt,
-        acceptedAnswers: aiGeneratedContent.acceptedAnswers,
-        // Ưu tiên giá trị từ AI, nếu không có thì dùng giá trị đầu vào
-        isCaseSensitive: (_a = aiGeneratedContent.isCaseSensitive) != null ? _a : clientInput.isCaseSensitive,
-        explanation: aiGeneratedContent.explanation,
-        points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
-      };
-      try {
-        const validatedQuestion = ShortAnswerQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
-      }
-    } else {
-      throw new Error("AI did not return content for the Short Answer question.");
-    }
-  } catch (error) {
-    console.error("Error generating Short Answer question:", error);
-    throw new Error(`Failed to generate Short Answer question: ${error.message}`);
-  }
-}
-function extractJsonFromMarkdown8(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-zod.z.object({
-  topic: zod.z.string().describe("The topic for the question."),
-  language: zod.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  contextDescription: zod.z.string().optional().describe("A specific context or scenario for the question."),
-  selectedContextId: zod.z.string().optional().describe("The ID of the selected context.")
-});
-zod.z.object({
-  prompt: zod.z.string().describe("The statement to be evaluated as true or false."),
-  correctAnswer: zod.z.boolean().describe("The correct answer (true or false)."),
-  explanation: zod.z.string().optional().describe("A brief explanation of why the answer is correct."),
-  points: zod.z.number().optional().default(10),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: zod.z.string().optional()
-});
-var TrueFalseQuestionZodSchema = zod.z.object({
-  id: zod.z.string(),
-  questionType: zod.z.literal("true_false"),
-  prompt: zod.z.string().min(1),
-  correctAnswer: zod.z.boolean(),
-  points: zod.z.number().min(0).optional(),
-  explanation: zod.z.string().optional(),
-  learningObjective: zod.z.string().optional(),
-  glossary: zod.z.array(zod.z.string()).optional(),
-  bloomLevel: zod.z.string().optional(),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: zod.z.string().optional(),
-  gradeBand: zod.z.string().optional(),
-  course: zod.z.string().optional(),
-  category: zod.z.string().optional(),
-  topic: zod.z.string().optional()
-});
-zod.z.object({
-  question: TrueFalseQuestionZodSchema.optional().describe("The generated True/False question.")
-});
-async function generateTrueFalseQuestion(clientInput, apiKey) {
-  try {
-    const ai = genkit.genkit({
-      plugins: [googleai.googleAI({ apiKey })],
-      model: googleai.gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer.
-Generate a single True/False question in ${clientInput.language} based on the following inputs.
-
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "The Earth is the fourth planet from the Sun.",
-  "correctAnswer": false,
-  "explanation": "The Earth is the third planet from the Sun. Mars is the fourth.",
-  "points": 10,
-  "difficulty": "easy",
-  "topic": "Astronomy"
-}
-
-Requirements:
-- The 'prompt' must be a clear statement that is definitively true or false.
-- 'correctAnswer' must be a boolean value (true or false).
-- The content of 'prompt', 'explanation', and 'topic' must be in ${clientInput.language}.
-
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-${clientInput.contextDescription ? `Context: ${clientInput.contextDescription}` : ""}
-Difficulty: ${clientInput.difficulty}
-
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown8(rawText);
-    console.log("AI Response:", jsonText);
-    const aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent) {
-      const completeQuestion = {
-        id: generateUniqueId("tf_ai_"),
-        questionType: "true_false",
-        prompt: aiGeneratedContent.prompt,
-        correctAnswer: aiGeneratedContent.correctAnswer,
-        explanation: aiGeneratedContent.explanation,
-        points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
-      };
-      try {
-        const validatedQuestion = TrueFalseQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
-      }
-    } else {
-      throw new Error("AI did not return content for the True/False question.");
-    }
-  } catch (error) {
-    console.error("Error generating True/False question:", error);
-    throw new Error(`Failed to generate True/False question: ${error.message}`);
-  }
-}
-function extractJsonFromMarkdown9(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-var fullQuizSupportedQuestionTypesArray = [
-  "true_false",
-  "multiple_choice",
-  "multiple_response",
-  "short_answer",
-  "numeric",
-  "fill_in_the_blanks",
-  "sequence",
-  "matching"
-];
-var BloomLevelStringsEnum = zod.z.enum(["remembering", "understanding", "applying"]);
-zod.z.object({
-  language: zod.z.string().optional().default("English").describe('The language for the quiz plan (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  totalQuestions: zod.z.number().int().min(1).max(50),
-  topics: zod.z.array(zod.z.object({
-    topic: zod.z.string().min(1),
-    ratio: zod.z.number().min(0).max(100)
-  })).min(1),
-  bloomLevels: zod.z.array(zod.z.object({
-    level: BloomLevelStringsEnum,
-    ratio: zod.z.number().min(0).max(100)
-  })).min(1),
-  selectedContextIds: zod.z.array(zod.z.string()).optional(),
-  selectedQuestionTypes: zod.z.array(zod.z.enum(fullQuizSupportedQuestionTypesArray)).min(1)
-});
-var PlannedQuestionSchema = zod.z.object({
-  plannedTopic: zod.z.string().min(1).describe("The specific topic for this question."),
-  plannedQuestionType: zod.z.enum(fullQuizSupportedQuestionTypesArray).describe("The specific question type chosen."),
-  plannedBloomLevel: BloomLevelStringsEnum.describe("The Bloom's level assigned.")
-});
-var GenerateQuizPlanOutputSchema = zod.z.object({
-  quizPlan: zod.z.array(PlannedQuestionSchema).describe("A detailed plan for each question in the quiz.")
-});
-async function generateQuizPlan(clientInput, apiKey) {
-  try {
-    const totalTopicRatio = clientInput.topics.reduce((sum, t) => sum + t.ratio, 0);
-    if (Math.abs(totalTopicRatio - 100) > 1) {
-      throw new Error(`Total topic ratio must be 100%. Current sum: ${totalTopicRatio.toFixed(1)}%`);
-    }
-    const totalBloomRatio = clientInput.bloomLevels.reduce((sum, b) => sum + b.ratio, 0);
-    if (Math.abs(totalBloomRatio - 100) > 1) {
-      throw new Error(`Total Bloom level ratio must be 100%. Current sum: ${totalBloomRatio.toFixed(1)}%`);
-    }
-    const ai = genkit.genkit({
-      plugins: [googleai.googleAI({ apiKey })],
-      model: googleai.gemini20Flash
-    });
-    const topicsDistribution = clientInput.topics.map((t) => `- Topic: "${t.topic}", Ratio: ${t.ratio}%`).join("\n    ");
-    const bloomDistribution = clientInput.bloomLevels.map((b) => `- Level: "${b.level}", Ratio: ${b.ratio}%`).join("\n    ");
-    const allowedQuestionTypes = clientInput.selectedQuestionTypes.map((t) => `'${t}'`).join(", ");
-    const promptText = `You are an expert educational content planner. Your task is to generate a detailed plan for a quiz in ${clientInput.language}.
-
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "quizPlan": [
-    { "plannedTopic": "Specific Topic A", "plannedQuestionType": "multiple_choice", "plannedBloomLevel": "remembering" },
-    { "plannedTopic": "Specific Topic B", "plannedQuestionType": "true_false", "plannedBloomLevel": "understanding" }
-  ]
-}
-
-Constraints and Guidelines:
-1.  **Total Questions**: The output 'quizPlan' array must contain exactly ${clientInput.totalQuestions} elements.
-2.  **Topic Distribution**: Distribute the questions across the following topics according to their specified ratios. Match these ratios as closely as possible.
-    ${topicsDistribution}
-3.  **Bloom Level Distribution**: Distribute the questions across the following Bloom's Taxonomy levels according to their specified ratios.
-    ${bloomDistribution}
-4.  **Allowed Question Types**: For each planned question, 'plannedQuestionType' must be one of these types: ${allowedQuestionTypes}. Use a variety of these types.
-5.  **Topic Specificity**: The 'plannedTopic' for each question should be a specific sub-topic or aspect related to one of the main topics provided, and must be in ${clientInput.language}.
-
-Carefully calculate the number of questions for each topic and Bloom level based on the total number of questions and the provided ratios. If ratios lead to fractional questions, round to the nearest whole number while ensuring the total number of questions remains exactly ${clientInput.totalQuestions}.
-The final 'quizPlan' array must have exactly ${clientInput.totalQuestions} elements.
-
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown9(rawText);
-    console.log("AI Response:", jsonText);
-    const aiGeneratedContent = JSON.parse(jsonText);
-    if (!aiGeneratedContent || !aiGeneratedContent.quizPlan) {
-      throw new Error("AI did not return a valid quiz plan structure.");
-    }
-    if (aiGeneratedContent.quizPlan.length !== clientInput.totalQuestions) {
-      throw new Error(`AI planned for ${aiGeneratedContent.quizPlan.length} questions, but ${clientInput.totalQuestions} were requested. The plan must match the total number of questions.`);
-    }
-    aiGeneratedContent.quizPlan.forEach((item, index) => {
-      if (!clientInput.selectedQuestionTypes.includes(item.plannedQuestionType)) {
-        throw new Error(`AI planned question ${index + 1} with a disallowed question type: '${item.plannedQuestionType}'`);
-      }
-    });
-    try {
-      const validatedPlan = GenerateQuizPlanOutputSchema.parse(aiGeneratedContent);
-      return validatedPlan;
-    } catch (validationError) {
-      console.error("Quiz plan validation failed:", validationError);
-      throw new Error(`Generated quiz plan failed validation: ${validationError}`);
-    }
-  } catch (error) {
-    console.error("Error generating Quiz Plan:", error);
-    throw new Error(`Failed to generate Quiz Plan: ${error.message}`);
-  }
-}
-var internalContextOptions = [
-  // ... (giữ nguyên mảng này)
-  { contextId: "THEO_ABS", contextDescription: "L\xFD thuy\u1EBFt/Tr\u1EEBu t\u01B0\u1EE3ng" },
-  { contextId: "SPEC_CASE", contextDescription: "V\xED d\u1EE5 C\u1EE5 th\u1EC3/Tr\u01B0\u1EDDng h\u1EE3p Ri\xEAng" },
-  { contextId: "NAT_OBS", contextDescription: "Hi\u1EC7n t\u01B0\u1EE3ng T\u1EF1 nhi\xEAn/Quan s\xE1t" },
-  { contextId: "TECH_ENG", contextDescription: "\u1EE8ng d\u1EE5ng C\xF4ng ngh\u1EC7/K\u1EF9 thu\u1EADt" },
-  { contextId: "EXP_INV", contextDescription: "Th\xED nghi\u1EC7m/\u0110i\u1EC1u tra Khoa h\u1ECDc" },
-  { contextId: "REAL_PROB", contextDescription: "V\u1EA5n \u0111\u1EC1 Th\u1EF1c t\u1EBF/X\xE3 h\u1ED9i/M\xF4i tr\u01B0\u1EDDng" },
-  { contextId: "DATA_MOD", contextDescription: "Di\u1EC5n gi\u1EA3i D\u1EEF li\u1EC7u/M\xF4 h\xECnh h\xF3a" },
-  { contextId: "HIST_SCI", contextDescription: "L\u1ECBch s\u1EED/Ph\xE1t tri\u1EC3n Khoa h\u1ECDc" },
-  { contextId: "INTERDISC", contextDescription: "Li\xEAn ng\xE0nh (Interdisciplinary)" },
-  { contextId: "HYPO_COMP", contextDescription: "Gi\u1EA3 \u0111\u1ECBnh/So s\xE1nh T\xECnh hu\u1ED1ng" }
-];
-var calculateCombinedDifficulty = (contextId, bloomLevel, qType, generalCustomContextInput) => {
-  let contextScore = 1;
-  const selectedContext = contextId ? internalContextOptions.find((c) => c.contextId === contextId) : void 0;
-  if (selectedContext) {
-    if (["THEO_ABS", "HIST_SCI"].includes(selectedContext.contextId)) contextScore = 1;
-    else if (["SPEC_CASE", "NAT_OBS", "DATA_MOD", "INTERDISC", "HYPO_COMP"].includes(selectedContext.contextId)) contextScore = 2;
-    else if (["TECH_ENG", "EXP_INV", "REAL_PROB"].includes(selectedContext.contextId)) contextScore = 3;
-  } else if (generalCustomContextInput == null ? void 0 : generalCustomContextInput.trim()) {
-    contextScore = 2;
-  }
-  let bloomScore = 1;
-  if (bloomLevel === "understanding") bloomScore = 2;
-  else if (bloomLevel === "applying") bloomScore = 3;
-  let questionTypeScore = 1;
-  switch (qType) {
-    case "true_false":
-    case "multiple_choice":
-    case "short_answer":
-      questionTypeScore = 1;
-      break;
-    case "matching":
-    case "fill_in_the_blanks":
-    case "numeric":
-      questionTypeScore = 2;
-      break;
-    case "sequence":
-    case "multiple_response":
-    case "drag_and_drop":
-      questionTypeScore = 3;
-      break;
-    default:
-      questionTypeScore = 1;
-  }
-  const totalScore = bloomScore + contextScore + questionTypeScore;
-  if (totalScore <= 4) return "easy";
-  if (totalScore <= 6) return "medium";
-  return "hard";
-};
-var PlannedQuestionSchema2 = zod.z.object({
-  plannedTopic: zod.z.string().min(1),
-  plannedQuestionType: zod.z.string(),
-  // Giữ dạng string để linh hoạt, sẽ kiểm tra trong logic
-  plannedBloomLevel: zod.z.enum(["remembering", "understanding", "applying"]),
-  plannedContextId: zod.z.string().optional()
-});
-zod.z.object({
-  quizPlan: zod.z.array(PlannedQuestionSchema2).min(1),
-  language: zod.z.string().optional().default("English").describe("The language for the generated questions."),
-  // <-- ĐÃ THÊM
-  selectedContextIds: zod.z.array(zod.z.string()).optional(),
-  customContextInput: zod.z.string().optional()
-});
-var GenerationErrorSchema = zod.z.object({
-  plannedQuestionIndex: zod.z.number(),
-  plannedTopic: zod.z.string(),
-  plannedQuestionType: zod.z.string(),
-  error: zod.z.string()
-});
-zod.z.object({
-  generatedQuestions: zod.z.array(zod.z.any()),
-  // z.any() là thực tế vì union của tất cả các loại câu hỏi rất phức tạp
-  errors: zod.z.array(GenerationErrorSchema).optional()
-});
-async function generateQuestionsFromQuizPlan(clientInput, apiKey) {
-  var _a, _b;
-  const { quizPlan, selectedContextIds, customContextInput, language } = clientInput;
-  const generatedQuestions = [];
-  const errors = [];
-  for (let i = 0; i < quizPlan.length; i++) {
-    const plannedQ = quizPlan[i];
-    let generationError = null;
-    try {
-      let contextDescriptionForAI;
-      let contextIdForDifficultyCalc = plannedQ.plannedContextId;
-      if (plannedQ.plannedContextId && plannedQ.plannedContextId !== "__custom__") {
-        contextDescriptionForAI = (_a = internalContextOptions.find((c) => c.contextId === plannedQ.plannedContextId)) == null ? void 0 : _a.contextDescription;
-      } else if (plannedQ.plannedContextId === "__custom__") {
-        contextDescriptionForAI = customContextInput == null ? void 0 : customContextInput.trim();
-      } else if ((selectedContextIds == null ? void 0 : selectedContextIds[0]) && selectedContextIds[0] !== "__custom__") {
-        contextDescriptionForAI = (_b = internalContextOptions.find((c) => c.contextId === selectedContextIds[0])) == null ? void 0 : _b.contextDescription;
-        if (!contextIdForDifficultyCalc) contextIdForDifficultyCalc = selectedContextIds[0];
-      } else if (customContextInput == null ? void 0 : customContextInput.trim()) {
-        contextDescriptionForAI = customContextInput.trim();
-        if (!contextIdForDifficultyCalc) contextIdForDifficultyCalc = "__custom__";
-      }
-      const difficultyForAI = calculateCombinedDifficulty(
-        contextIdForDifficultyCalc,
-        plannedQ.plannedBloomLevel,
-        plannedQ.plannedQuestionType,
-        contextDescriptionForAI
-      );
-      const baseClientInput = {
-        topic: plannedQ.plannedTopic,
-        language,
-        // <-- TRUYỀN `language` VÀO
-        difficulty: difficultyForAI,
-        contextDescription: contextDescriptionForAI,
-        selectedContextId: plannedQ.plannedContextId || contextIdForDifficultyCalc
-      };
-      let result = {};
-      switch (plannedQ.plannedQuestionType) {
-        case "true_false":
-          result = await generateTrueFalseQuestion(baseClientInput, apiKey);
-          break;
-        case "multiple_choice":
-          result = await generateMCQQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfOptions: 4 }), apiKey);
-          break;
-        case "multiple_response":
-          result = await generateMRQQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfOptions: 5, minCorrectAnswers: 2, maxCorrectAnswers: 3 }), apiKey);
-          break;
-        case "short_answer":
-          result = await generateShortAnswerQuestion(__spreadProps(__spreadValues({}, baseClientInput), { isCaseSensitive: false }), apiKey);
-          break;
-        case "numeric":
-          result = await generateNumericQuestion(__spreadProps(__spreadValues({}, baseClientInput), { allowDecimals: true }), apiKey);
-          break;
-        case "fill_in_the_blanks":
-          result = await generateFillInTheBlanksQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfBlanks: 2, isCaseSensitive: false }), apiKey);
-          break;
-        case "sequence":
-          result = await generateSequenceQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfItems: 4 }), apiKey);
-          break;
-        case "matching":
-          result = await generateMatchingQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfPairs: 4, shuffleOptions: true }), apiKey);
-          break;
-        default:
-          generationError = `Question type "${plannedQ.plannedQuestionType}" is not supported for automated generation.`;
-      }
-      if (result.question) {
-        const question = result.question;
-        question.topic = plannedQ.plannedTopic;
-        question.bloomLevel = plannedQ.plannedBloomLevel;
-        question.difficulty = difficultyForAI;
-        question.contextCode = baseClientInput.selectedContextId;
-        if (question.points === void 0) question.points = 10;
-        generatedQuestions.push(question);
-      } else if (!generationError) {
-        generationError = `AI did not return a question object for type '${plannedQ.plannedQuestionType}'.`;
-      }
-    } catch (e) {
-      generationError = e.message || `An unknown error occurred.`;
-    }
-    if (generationError) {
-      console.error(`Error generating question at index ${i} (Topic: ${plannedQ.plannedTopic}): ${generationError}`);
-      errors.push({
-        plannedQuestionIndex: i,
-        plannedTopic: plannedQ.plannedTopic,
-        plannedQuestionType: plannedQ.plannedQuestionType,
-        error: generationError
-      });
-    }
-  }
-  return { generatedQuestions, errors: errors.length > 0 ? errors : void 0 };
-}
-
-exports.generateFillInTheBlanksQuestion = generateFillInTheBlanksQuestion;
-exports.generateMCQQuestion = generateMCQQuestion;
-exports.generateMRQQuestion = generateMRQQuestion;
-exports.generateMatchingQuestion = generateMatchingQuestion;
-exports.generateNumericQuestion = generateNumericQuestion;
-exports.generateQuestionsFromQuizPlan = generateQuestionsFromQuizPlan;
-exports.generateQuizPlan = generateQuizPlan;
-exports.generateSequenceQuestion = generateSequenceQuestion;
-exports.generateShortAnswerQuestion = generateShortAnswerQuestion;
-exports.generateTrueFalseQuestion = generateTrueFalseQuestion;