@thanh01.pmt/interactive-quiz-kit 1.0.8 → 1.0.10

package/dist/index.js

@@ -47,6 +47,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  APIKeyService: () => APIKeyService,
+  GEMINI_API_KEY_SERVICE_NAME: () => GEMINI_API_KEY_SERVICE_NAME,
+  QuizEditorService: () => QuizEditorService,
   QuizEngine: () => QuizEngine,
   SCORMService: () => SCORMService,
   cn: () => cn,
@@ -1397,6 +1400,8 @@ var emptyQuiz = {
   description: "",
   questions: [],
   settings: {
+    language: "English",
+    // <-- ĐÃ THÊM
     shuffleQuestions: false,
     shuffleOptions: false,
     showCorrectAnswers: "end_of_quiz",
@@ -1459,677 +1464,1024 @@ var exportQuizAsSCORMZip = async (quiz, options) => {
   }
 };
 
-// src/ai/genkit.ts
-var import_genkit = require("genkit");
-var import_googleai = require("@genkit-ai/googleai");
-var ai = (0, import_genkit.genkit)({
-  plugins: [(0, import_googleai.googleAI)()],
-  model: "googleai/gemini-2.0-flash"
-});
+// src/services/APIKeyService.ts
+var GEMINI_API_KEY_SERVICE_NAME = "gemini";
+var LOCAL_STORAGE_PREFIX = "iqk_api_keys_";
+function _encode(data) {
+  if (typeof window !== "undefined" && typeof window.btoa === "function") {
+    try {
+      return window.btoa(data);
+    } catch (e) {
+      console.error("Base64 encoding (btoa) failed:", e);
+      return data;
+    }
+  }
+  return data;
+}
+function _decode(data) {
+  if (typeof window !== "undefined" && typeof window.atob === "function") {
+    try {
+      return window.atob(data);
+    } catch (e) {
+      console.error("Base64 decoding (atob) failed:", e);
+      return data;
+    }
+  }
+  return data;
+}
+var APIKeyService = class {
+  static getStorageKey(serviceName) {
+    return `${LOCAL_STORAGE_PREFIX}${serviceName}`;
+  }
+  /**
+   * Saves an API key to localStorage. The key is mildly obfuscated using Base64.
+   * @param serviceName - The name of the service (e.g., 'gemini').
+   * @param apiKey - The API key to save.
+   */
+  static saveAPIKey(serviceName, apiKey) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const encodedKey = _encode(apiKey);
+        localStorage.setItem(this.getStorageKey(serviceName), encodedKey);
+      } catch (e) {
+        console.error(`Error saving API key for ${serviceName} to localStorage:`, e);
+      }
+    } else {
+      console.warn("localStorage is not available. APIKeyService cannot save keys.");
+    }
+  }
+  /**
+   * Retrieves an API key from localStorage.
+   * @param serviceName - The name of the service.
+   * @returns The decoded API key, or null if not found or if localStorage is unavailable.
+   */
+  static getAPIKey(serviceName) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        const storedKey = localStorage.getItem(this.getStorageKey(serviceName));
+        if (storedKey) {
+          return _decode(storedKey);
+        }
+      } catch (e) {
+        console.error(`Error retrieving API key for ${serviceName} from localStorage:`, e);
+      }
+    } else {
+    }
+    return null;
+  }
+  /**
+   * Removes an API key from localStorage.
+   * @param serviceName - The name of the service.
+   */
+  static removeAPIKey(serviceName) {
+    if (typeof window !== "undefined" && window.localStorage) {
+      try {
+        localStorage.removeItem(this.getStorageKey(serviceName));
+      } catch (e) {
+        console.error(`Error removing API key for ${serviceName} from localStorage:`, e);
+      }
+    } else {
+    }
+  }
+  /**
+   * Checks if an API key exists in localStorage for the given service.
+   * @param serviceName - The name of the service.
+   * @returns True if a key exists, false otherwise.
+   */
+  static hasAPIKey(serviceName) {
+    return this.getAPIKey(serviceName) !== null;
+  }
+};
+
+// src/services/QuizEditorService.ts
+var QuizEditorService = class {
+  constructor(initialQuiz) {
+    this.quiz = JSON.parse(JSON.stringify(initialQuiz));
+  }
+  /**
+   * Returns the current state of the quiz configuration.
+   * @returns The current QuizConfig object.
+   */
+  getQuiz() {
+    return this.quiz;
+  }
+  /**
+   * Creates a new, "empty" question object based on the specified question type.
+   * @param type The type of question to create.
+   * @returns A new QuizQuestion object with default values.
+   */
+  static createNewQuestionTemplate(type) {
+    const baseNewQuestion = {
+      id: generateUniqueId(`new_${type}_`),
+      // 'new_' prefix indicates it's a new, unsaved question
+      questionType: type,
+      prompt: "",
+      points: 10,
+      difficulty: "medium"
+    };
+    switch (type) {
+      case "true_false":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "true_false", correctAnswer: true });
+      case "multiple_choice":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "multiple_choice", options: [], correctAnswerId: "" });
+      case "multiple_response":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "multiple_response", options: [], correctAnswerIds: [] });
+      case "short_answer":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "short_answer", acceptedAnswers: [""], isCaseSensitive: false });
+      case "numeric":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "numeric", answer: 0 });
+      case "fill_in_the_blanks": {
+        const blankId = generateUniqueId("blank_");
+        return __spreadProps(__spreadValues({}, baseNewQuestion), {
+          questionType: "fill_in_the_blanks",
+          segments: [
+            { type: "text", content: "Your text before " },
+            { type: "blank", id: blankId },
+            { type: "text", content: " and after." }
+          ],
+          answers: [{ blankId, acceptedValues: [""] }],
+          isCaseSensitive: false
+        });
+      }
+      case "sequence":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "sequence", items: [], correctOrder: [] });
+      case "matching":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "matching", prompts: [], options: [], correctAnswerMap: [], shuffleOptions: true });
+      case "drag_and_drop":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "drag_and_drop", draggableItems: [], dropZones: [], answerMap: [] });
+      case "hotspot":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), { questionType: "hotspot", imageUrl: "", hotspots: [], correctHotspotIds: [] });
+      case "blockly_programming":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), {
+          questionType: "blockly_programming",
+          toolboxDefinition: '<xml xmlns="https://developers.google.com/blockly/xml"></xml>',
+          initialWorkspace: "",
+          solutionWorkspaceXML: "",
+          solutionGeneratedCode: ""
+        });
+      case "scratch_programming":
+        return __spreadProps(__spreadValues({}, baseNewQuestion), {
+          questionType: "scratch_programming",
+          toolboxDefinition: '<xml xmlns="https://developers.google.com/blockly/xml"></xml>',
+          initialWorkspace: "",
+          solutionWorkspaceXML: "",
+          solutionGeneratedCode: ""
+        });
+      default:
+        const _exhaustiveCheck = type;
+        throw new Error(`Question type "${_exhaustiveCheck}" is not supported for creation.`);
+    }
+  }
+  /**
+   * Adds a new question to the quiz. If the question ID is temporary, a new permanent ID is generated.
+   * @param question The question object to add.
+   * @returns The updated QuizConfig.
+   */
+  addQuestion(question) {
+    const newQuestion = __spreadValues({}, question);
+    if (newQuestion.id.startsWith("new_")) {
+      newQuestion.id = generateUniqueId(`${newQuestion.questionType}_`);
+    }
+    this.quiz.questions.push(newQuestion);
+    return this.quiz;
+  }
+  /**
+   * Updates an existing question in the quiz.
+   * @param updatedQuestion The full question object with changes.
+   * @returns The updated QuizConfig.
+   */
+  updateQuestion(updatedQuestion) {
+    const questionIndex = this.quiz.questions.findIndex((q) => q.id === updatedQuestion.id);
+    if (questionIndex === -1) {
+      throw new Error(`Question with ID "${updatedQuestion.id}" not found.`);
+    }
+    this.quiz.questions[questionIndex] = updatedQuestion;
+    return this.quiz;
+  }
+  /**
+   * Deletes a question from the quiz by its index.
+   * @param index The index of the question to delete.
+   * @returns The updated QuizConfig.
+   */
+  deleteQuestionByIndex(index) {
+    if (index < 0 || index >= this.quiz.questions.length) {
+      throw new Error(`Invalid index ${index} for question deletion.`);
+    }
+    this.quiz.questions.splice(index, 1);
+    return this.quiz;
+  }
+  /**
+   * Moves a question from one position to another.
+   * @param fromIndex The current index of the question.
+   * @param toIndex The target index for the question.
+   * @returns The updated QuizConfig.
+   */
+  moveQuestion(fromIndex, toIndex) {
+    if (fromIndex < 0 || fromIndex >= this.quiz.questions.length || toIndex < 0 || toIndex >= this.quiz.questions.length) {
+      throw new Error("Invalid index for moving question.");
+    }
+    const [movedItem] = this.quiz.questions.splice(fromIndex, 1);
+    this.quiz.questions.splice(toIndex, 0, movedItem);
+    return this.quiz;
+  }
+};
 
 // src/ai/flows/generate-fitb-question.ts
-var import_genkit3 = require("genkit");
-var GenerateFillInTheBlanksQuestionInputSchema = import_genkit3.z.object({
-  topic: import_genkit3.z.string().describe("The topic for the question."),
-  difficulty: import_genkit3.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfBlanks: import_genkit3.z.number().int().min(1).max(5).optional().default(1).describe("Number of blanks to include (1-5)."),
-  isCaseSensitive: import_genkit3.z.boolean().optional().default(false).describe("Whether answers should be case-sensitive."),
-  contextDescription: import_genkit3.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: import_genkit3.z.string().optional().describe("The ID of the selected context, if any.")
+var import_zod = require("zod");
+var import_genkit = require("genkit");
+var import_googleai = require("@genkit-ai/googleai");
+function extractJsonFromMarkdown(text) {
+  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  return match ? match[1].trim() : text.trim();
+}
+var GenerateFillInTheBlanksQuestionClientInputSchema = import_zod.z.object({
+  topic: import_zod.z.string().describe("The topic for the question."),
+  language: import_zod.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
+  // <-- ĐÃ THÊM
+  difficulty: import_zod.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  numberOfBlanks: import_zod.z.number().int().min(1).max(5).optional().default(1).describe("Number of blanks to include (1-5)."),
+  isCaseSensitive: import_zod.z.boolean().optional().default(false).describe("Whether answers should be case-sensitive."),
+  contextDescription: import_zod.z.string().optional().describe("A specific context or scenario for the question."),
+  selectedContextId: import_zod.z.string().optional().describe("The ID of the selected context.")
 });
-var AIFillInTheBlanksOutputFieldsSchema = import_genkit3.z.object({
-  prompt: import_genkit3.z.string().describe("The overall instruction for the question (e.g., 'Fill in the blanks in the sentence below.')."),
-  sentenceWithPlaceholders: import_genkit3.z.string().describe("The sentence containing placeholders for blanks, e.g., 'The capital of {{country}} is {{city}}.' or 'Water is made of {{element1}} and {{element2}}.' Placeholders should be distinct and clearly marked, e.g., using {{placeholder_name}} format."),
-  blanks: import_genkit3.z.array(
-    import_genkit3.z.object({
-      placeholder: import_genkit3.z.string().describe("The exact placeholder string used in 'sentenceWithPlaceholders' (e.g., 'country', 'element1'). Do not include the curly braces."),
-      acceptedAnswers: import_genkit3.z.array(import_genkit3.z.string()).min(1).describe("An array of acceptable answers for this blank.")
+var AIFillInTheBlanksOutputFieldsSchema = import_zod.z.object({
+  prompt: import_zod.z.string().describe("The overall instruction for the question."),
+  sentenceWithPlaceholders: import_zod.z.string().describe("The sentence containing placeholders like {{placeholder_name}}."),
+  blanks: import_zod.z.array(
+    import_zod.z.object({
+      placeholder: import_zod.z.string().describe("The placeholder name (without curly braces)."),
+      acceptedAnswers: import_zod.z.array(import_zod.z.string().min(1)).min(1).describe("Array of acceptable answers.")
     })
-  ).min(1).describe("An array defining each placeholder and its accepted answers."),
-  isCaseSensitive: import_genkit3.z.boolean().optional().describe("Should answer evaluation be case sensitive? Defaults to input or false."),
-  explanation: import_genkit3.z.string().optional().describe("Explanation for the correct answer(s)."),
-  points: import_genkit3.z.number().optional().default(10),
-  difficulty: import_genkit3.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: import_genkit3.z.string().optional()
+  ).min(1),
+  isCaseSensitive: import_zod.z.boolean().optional(),
+  explanation: import_zod.z.string().optional(),
+  points: import_zod.z.number().optional().default(10),
+  difficulty: import_zod.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: import_zod.z.string().optional()
 });
-var FillInTheBlanksQuestionZodSchema = import_genkit3.z.object({
-  id: import_genkit3.z.string(),
-  questionType: import_genkit3.z.literal("fill_in_the_blanks"),
-  prompt: import_genkit3.z.string(),
-  segments: import_genkit3.z.array(import_genkit3.z.object({ type: import_genkit3.z.enum(["text", "blank"]), content: import_genkit3.z.string().optional(), id: import_genkit3.z.string().optional() })),
-  answers: import_genkit3.z.array(import_genkit3.z.object({ blankId: import_genkit3.z.string(), acceptedValues: import_genkit3.z.array(import_genkit3.z.string()) })),
-  isCaseSensitive: import_genkit3.z.boolean().optional(),
-  points: import_genkit3.z.number().optional(),
-  explanation: import_genkit3.z.string().optional(),
-  learningObjective: import_genkit3.z.string().optional(),
-  glossary: import_genkit3.z.array(import_genkit3.z.string()).optional(),
-  bloomLevel: import_genkit3.z.string().optional(),
-  difficulty: import_genkit3.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: import_genkit3.z.string().optional(),
-  gradeBand: import_genkit3.z.string().optional(),
-  course: import_genkit3.z.string().optional(),
-  category: import_genkit3.z.string().optional(),
-  topic: import_genkit3.z.string().optional()
+var FillInTheBlanksQuestionZodSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  questionType: import_zod.z.literal("fill_in_the_blanks"),
+  prompt: import_zod.z.string().min(1),
+  segments: import_zod.z.array(import_zod.z.object({
+    type: import_zod.z.enum(["text", "blank"]),
+    content: import_zod.z.string().optional(),
+    // Only for 'text' type
+    id: import_zod.z.string().optional()
+    // Only for 'blank' type
+  })).min(1),
+  answers: import_zod.z.array(import_zod.z.object({
+    blankId: import_zod.z.string(),
+    acceptedValues: import_zod.z.array(import_zod.z.string().min(1)).min(1)
+  })).min(1),
+  isCaseSensitive: import_zod.z.boolean().optional(),
+  points: import_zod.z.number().min(0).optional(),
+  explanation: import_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"]
 });
-var GenerateFillInTheBlanksQuestionOutputSchema = import_genkit3.z.object({
-  question: FillInTheBlanksQuestionZodSchema.optional().describe("The generated Fill-In-The-Blanks question.")
+var GenerateFillInTheBlanksQuestionOutputSchema = import_zod.z.object({
+  question: FillInTheBlanksQuestionZodSchema.optional().describe("The generated question.")
 });
-async function generateFillInTheBlanksQuestion(input) {
-  return generateFillInTheBlanksQuestionFlow(input);
+async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
+  var _a;
+  try {
+    const ai = (0, import_genkit.genkit)({
+      plugins: [(0, import_googleai.googleAI)({ apiKey })],
+      model: import_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"
 }
-var fitbAIPrompt = ai.definePrompt({
-  name: "fitbQuestionGeneratorPrompt",
-  input: { schema: GenerateFillInTheBlanksQuestionInputSchema },
-  output: { schema: AIFillInTheBlanksOutputFieldsSchema },
-  prompt: `You are an expert quiz question writer.
-Generate a single Fill-In-The-Blanks question with approximately {{{numberOfBlanks}}} blanks.
-Provide:
-1.  An overall 'prompt' or instruction.
-2.  A 'sentenceWithPlaceholders' where blanks are clearly marked with double curly braces, e.g., "{{blank_name}}". Each placeholder name inside the braces must be unique.
-3.  A 'blanks' array, where each object defines a 'placeholder' (matching a name from the sentence, without braces) and its 'acceptedAnswers'.
-4.  Specify 'isCaseSensitive' (defaulting to {{{isCaseSensitive}}}).
-5.  Optional 'explanation', 'points' (default 10), refined 'topic', and 'difficulty'.
-
-Topic: {{{topic}}}
-{{#if contextDescription}}
-Context: {{{contextDescription}}}
-{{/if}}
-Difficulty: {{{difficulty}}}
-Target Number of Blanks: {{{numberOfBlanks}}}
-Case Sensitive: {{{isCaseSensitive}}}
-
-Example for 'sentenceWithPlaceholders': "The {{color_of_sky}} sky is beautiful, and the {{type_of_grass}} grass is green."
-Example for 'blanks' array entry for the above: { "placeholder": "color_of_sky", "acceptedAnswers": ["blue"] }
-
-Ensure your output strictly matches the requested JSON schema. The number of entries in the 'blanks' array should correspond to the number of unique placeholders in 'sentenceWithPlaceholders'.
-`
-});
-var generateFillInTheBlanksQuestionFlow = ai.defineFlow(
-  {
-    name: "generateFillInTheBlanksQuestionFlow",
-    inputSchema: GenerateFillInTheBlanksQuestionInputSchema,
-    outputSchema: GenerateFillInTheBlanksQuestionOutputSchema
-  },
-  async (input) => {
-    try {
-      const { output: aiGeneratedContent } = await fitbAIPrompt(input);
-      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
-          });
+
+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
         });
-        let remainingSentence = aiGeneratedContent.sentenceWithPlaceholders;
-        const placeholderRegex = /\{\{([^}]+)\}\}/g;
-        let lastIndex = 0;
-        let match;
-        while ((match = placeholderRegex.exec(remainingSentence)) !== null) {
-          const placeholderName = match[1];
-          const blankId = placeholderToBlankIdMap[placeholderName];
-          if (match.index > lastIndex) {
-            segments.push({ type: "text", content: remainingSentence.substring(lastIndex, match.index) });
-          }
-          if (blankId) {
-            segments.push({ type: "blank", id: blankId });
-          } else {
-            console.warn(`Placeholder {{${placeholderName}}} found in sentence but not in blanks definition. Treating as text.`);
-            segments.push({ type: "text", content: match[0] });
-          }
-          lastIndex = placeholderRegex.lastIndex;
-        }
-        if (lastIndex < remainingSentence.length) {
-          segments.push({ type: "text", content: remainingSentence.substring(lastIndex) });
-        }
-        if (answers.length === 0 && segments.some((s) => s.type === "blank")) {
-          throw new Error("AI generated blank segments but no corresponding answer definitions.");
+      });
+      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 (segments.filter((s) => s.type === "blank").length !== answers.length) {
-          console.warn(`Mismatch between number of blank segments (${segments.filter((s) => s.type === "blank").length}) and answer definitions (${answers.length}). Review AI output.`);
-          if (answers.length === 0 && segments.filter((s) => s.type === "blank").length > 0) {
-            throw new Error("AI generated blank segments but no answer definitions for them.");
-          }
+        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] });
         }
-        const completeQuestion = {
-          id: generateUniqueId("fitb_ai_"),
-          questionType: "fill_in_the_blanks",
-          prompt: aiGeneratedContent.prompt,
-          segments,
-          answers,
-          isCaseSensitive: aiGeneratedContent.isCaseSensitive === void 0 ? input.isCaseSensitive : aiGeneratedContent.isCaseSensitive,
-          explanation: aiGeneratedContent.explanation,
-          points: aiGeneratedContent.points,
-          topic: aiGeneratedContent.topic || input.topic,
-          difficulty: aiGeneratedContent.difficulty || input.difficulty,
-          contextCode: input.contextDescription ? input.selectedContextId : void 0
-        };
-        return { question: completeQuestion };
-      } else {
-        throw new Error("AI did not return content for the Fill-In-The-Blanks question.");
+        lastIndex = placeholderRegex.lastIndex;
       }
-    } catch (error) {
-      console.error("Error generating Fill-In-The-Blanks question in flow:", error);
-      throw new Error(`Failed to generate Fill-In-The-Blanks question: ${error.message}`);
+      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}`);
   }
-);
+}
 
 // src/ai/flows/generate-matching-question.ts
-var import_genkit5 = require("genkit");
-var GenerateMatchingQuestionInputSchema = import_genkit5.z.object({
-  topic: import_genkit5.z.string().describe("The topic for the question."),
-  difficulty: import_genkit5.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfPairs: import_genkit5.z.number().int().min(2).max(8).optional().default(4).describe("Number of pairs to match (2-8)."),
-  shuffleOptions: import_genkit5.z.boolean().optional().default(true).describe("Whether the options should be shuffled for the user."),
-  contextDescription: import_genkit5.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: import_genkit5.z.string().optional().describe("The ID of the selected context, if any.")
+var import_zod2 = require("zod");
+var import_genkit2 = require("genkit");
+var import_googleai2 = require("@genkit-ai/googleai");
+function extractJsonFromMarkdown2(text) {
+  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  return match ? match[1].trim() : text.trim();
+}
+var GenerateMatchingQuestionClientInputSchema = import_zod2.z.object({
+  topic: import_zod2.z.string().describe("The topic for the question."),
+  language: import_zod2.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
+  // <-- ĐÃ THÊM
+  difficulty: import_zod2.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  numberOfPairs: import_zod2.z.number().int().min(2).max(8).optional().default(4).describe("Number of pairs to match (2-8)."),
+  shuffleOptions: import_zod2.z.boolean().optional().default(true).describe("Whether the options should be shuffled."),
+  contextDescription: import_zod2.z.string().optional().describe("A specific context or scenario for the question."),
+  selectedContextId: import_zod2.z.string().optional().describe("The ID of the selected context.")
 });
-var AIMatchingOutputFieldsSchema = import_genkit5.z.object({
-  prompt: import_genkit5.z.string().describe("The overall instruction (e.g., 'Match the terms to their definitions.')."),
-  correctPairs: import_genkit5.z.array(
-    import_genkit5.z.object({
-      promptText: import_genkit5.z.string().describe("The text for a prompt item (e.g., a term)."),
-      optionText: import_genkit5.z.string().describe("The text for the corresponding option item (e.g., its definition).")
+var AIMatchingOutputFieldsSchema = import_zod2.z.object({
+  prompt: import_zod2.z.string().describe("The overall instruction (e.g., 'Match the terms to their definitions.')."),
+  correctPairs: import_zod2.z.array(
+    import_zod2.z.object({
+      promptText: import_zod2.z.string().min(1).describe("The text for a prompt item (e.g., a term)."),
+      optionText: import_zod2.z.string().min(1).describe("The text for the corresponding option item (e.g., its definition).")
     })
-  ).min(2).describe("An array of objects, each representing a correct prompt-option pair."),
-  explanation: import_genkit5.z.string().optional().describe("General explanation if needed."),
-  points: import_genkit5.z.number().optional().default(10),
-  difficulty: import_genkit5.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: import_genkit5.z.string().optional()
+  ).min(2),
+  explanation: import_zod2.z.string().optional(),
+  points: import_zod2.z.number().optional().default(10),
+  difficulty: import_zod2.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: import_zod2.z.string().optional()
 });
-var MatchingQuestionZodSchema = import_genkit5.z.object({
-  id: import_genkit5.z.string(),
-  questionType: import_genkit5.z.literal("matching"),
-  prompt: import_genkit5.z.string(),
-  prompts: import_genkit5.z.array(import_genkit5.z.object({ id: import_genkit5.z.string(), content: import_genkit5.z.string() })),
-  options: import_genkit5.z.array(import_genkit5.z.object({ id: import_genkit5.z.string(), content: import_genkit5.z.string() })),
-  correctAnswerMap: import_genkit5.z.array(import_genkit5.z.object({ promptId: import_genkit5.z.string(), optionId: import_genkit5.z.string() })),
-  shuffleOptions: import_genkit5.z.boolean().optional(),
-  points: import_genkit5.z.number().optional(),
-  explanation: import_genkit5.z.string().optional(),
-  learningObjective: import_genkit5.z.string().optional(),
-  glossary: import_genkit5.z.array(import_genkit5.z.string()).optional(),
-  bloomLevel: import_genkit5.z.string().optional(),
-  difficulty: import_genkit5.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: import_genkit5.z.string().optional(),
-  gradeBand: import_genkit5.z.string().optional(),
-  course: import_genkit5.z.string().optional(),
-  category: import_genkit5.z.string().optional(),
-  topic: import_genkit5.z.string().optional()
+var MatchingQuestionZodSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  questionType: import_zod2.z.literal("matching"),
+  prompt: import_zod2.z.string().min(1),
+  prompts: import_zod2.z.array(import_zod2.z.object({ id: import_zod2.z.string(), content: import_zod2.z.string().min(1) })).min(2),
+  options: import_zod2.z.array(import_zod2.z.object({ id: import_zod2.z.string(), content: import_zod2.z.string().min(1) })).min(2),
+  correctAnswerMap: import_zod2.z.array(import_zod2.z.object({ promptId: import_zod2.z.string(), optionId: import_zod2.z.string() })).min(2),
+  shuffleOptions: import_zod2.z.boolean().optional(),
+  points: import_zod2.z.number().min(0).optional(),
+  explanation: import_zod2.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"]
 });
-var GenerateMatchingQuestionOutputSchema = import_genkit5.z.object({
+var GenerateMatchingQuestionOutputSchema = import_zod2.z.object({
   question: MatchingQuestionZodSchema.optional().describe("The generated Matching question.")
 });
-async function generateMatchingQuestion(input) {
-  return generateMatchingQuestionFlow(input);
+async function generateMatchingQuestion(clientInput, apiKey) {
+  try {
+    const ai = (0, import_genkit2.genkit)({
+      plugins: [(0, import_googleai2.googleAI)({ apiKey })],
+      model: import_googleai2.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"
 }
-var matchingAIPrompt = ai.definePrompt({
-  name: "matchingQuestionGeneratorPrompt",
-  input: { schema: GenerateMatchingQuestionInputSchema },
-  output: { schema: AIMatchingOutputFieldsSchema },
-  prompt: `You are an expert quiz question writer.
-Generate a single Matching question with exactly {{{numberOfPairs}}} correct pairs.
-Provide:
-1.  An overall 'prompt' or instruction.
-2.  A 'correctPairs' array: each object in this array should contain a 'promptText' and its corresponding 'optionText'. These represent items that correctly match.
-3.  Optional 'explanation', 'points' (default 10), refined 'topic', and 'difficulty'.
-
-Topic: {{{topic}}}
-{{#if contextDescription}}
-Context: {{{contextDescription}}}
-{{/if}}
-Difficulty: {{{difficulty}}}
-Number of Pairs: {{{numberOfPairs}}}
-
-Ensure your output strictly matches the requested JSON schema. 'correctPairs' must have {{{numberOfPairs}}} elements.
-The promptText and optionText within each pair should be distinct and meaningful for a matching question.
-`
-});
-var generateMatchingQuestionFlow = ai.defineFlow(
-  {
-    name: "generateMatchingQuestionFlow",
-    inputSchema: GenerateMatchingQuestionInputSchema,
-    outputSchema: GenerateMatchingQuestionOutputSchema
-  },
-  async (input) => {
-    try {
-      const { output: aiGeneratedContent } = await matchingAIPrompt(input);
-      if (aiGeneratedContent) {
-        if (aiGeneratedContent.correctPairs.length !== input.numberOfPairs) {
-          throw new Error(`AI generated ${aiGeneratedContent.correctPairs.length} pairs, but ${input.numberOfPairs} were requested.`);
-        }
-        const finalPrompts = [];
-        const finalOptions = [];
-        const finalCorrectAnswerMap = [];
-        const promptTextToId = {};
-        const optionTextToId = {};
-        aiGeneratedContent.correctPairs.forEach((pair) => {
-          let promptId = promptTextToId[pair.promptText];
-          if (!promptId) {
-            promptId = generateUniqueId("m_p_");
-            promptTextToId[pair.promptText] = promptId;
-            finalPrompts.push({ id: promptId, content: pair.promptText });
-          }
-          let optionId = optionTextToId[pair.optionText];
-          if (!optionId) {
-            optionId = generateUniqueId("m_o_");
-            optionTextToId[pair.optionText] = optionId;
-            finalOptions.push({ id: optionId, content: pair.optionText });
-          }
-          if (!finalCorrectAnswerMap.find((m) => m.promptId === promptId && m.optionId === optionId)) {
-            finalCorrectAnswerMap.push({ promptId, optionId });
-          }
-        });
-        if (finalPrompts.length < input.numberOfPairs || finalOptions.length < input.numberOfPairs) {
-          console.warn(`AI generated ${finalPrompts.length} unique prompts and ${finalOptions.length} unique options for ${input.numberOfPairs} requested pairs. This might lead to an unbalanced matching question or indicate duplicate content from AI.`);
-        }
-        if (finalCorrectAnswerMap.length !== input.numberOfPairs) {
-          throw new Error(`Could not form the required ${input.numberOfPairs} unique mappings from AI output. AI provided ${finalCorrectAnswerMap.length} valid mappings.`);
-        }
-        const completeQuestion = {
-          id: generateUniqueId("match_ai_"),
-          questionType: "matching",
-          prompt: aiGeneratedContent.prompt,
-          prompts: finalPrompts,
-          options: finalOptions,
-          correctAnswerMap: finalCorrectAnswerMap,
-          shuffleOptions: input.shuffleOptions,
-          explanation: aiGeneratedContent.explanation,
-          points: aiGeneratedContent.points,
-          topic: aiGeneratedContent.topic || input.topic,
-          difficulty: aiGeneratedContent.difficulty || input.difficulty,
-          contextCode: input.contextDescription ? input.selectedContextId : void 0
-        };
-        return { question: completeQuestion };
-      } else {
-        throw new Error("AI did not return content for the Matching question.");
+
+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.`);
       }
-    } catch (error) {
-      console.error("Error generating Matching question in flow:", error);
-      throw new Error(`Failed to generate Matching question: ${error.message}`);
+      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}`);
   }
-);
+}
 
 // src/ai/flows/generate-mcq-question.ts
-var import_genkit7 = require("genkit");
-var GenerateMCQQuestionInputSchema = import_genkit7.z.object({
-  topic: import_genkit7.z.string().describe("The topic for the question."),
-  difficulty: import_genkit7.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfOptions: import_genkit7.z.number().int().min(2).max(6).optional().default(4).describe("Number of answer options to generate (2-6)."),
-  contextDescription: import_genkit7.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: import_genkit7.z.string().optional().describe("The ID of the selected context, if any.")
+var import_zod3 = require("zod");
+var import_genkit3 = require("genkit");
+var import_googleai3 = require("@genkit-ai/googleai");
+function extractJsonFromMarkdown3(text) {
+  return text.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
+}
+var GenerateMCQQuestionClientInputSchema = import_zod3.z.object({
+  topic: import_zod3.z.string().describe("The topic for the question."),
+  language: import_zod3.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
+  // <-- ĐÃ THÊM
+  difficulty: import_zod3.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  numberOfOptions: import_zod3.z.number().int().min(2).max(6).optional().default(4).describe("Number of answer options to generate (2-6)."),
+  contextDescription: import_zod3.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
+  selectedContextId: import_zod3.z.string().optional().describe("The ID of the selected context, if any.")
 });
-var AIMCQOutputFieldsSchema = import_genkit7.z.object({
-  prompt: import_genkit7.z.string().describe("The question statement itself."),
-  options: import_genkit7.z.array(
-    import_genkit7.z.object({
-      tempId: import_genkit7.z.string().describe("A temporary, unique identifier for this option (e.g., 'A', 'B', '1', '2')."),
-      text: import_genkit7.z.string().describe("The text content of this answer option.")
+var AIMCQOutputFieldsSchema = import_zod3.z.object({
+  prompt: import_zod3.z.string().describe("The question statement itself."),
+  options: import_zod3.z.array(
+    import_zod3.z.object({
+      tempId: import_zod3.z.string().describe("A temporary, unique identifier for this option (e.g., 'A', 'B', '1', '2')."),
+      text: import_zod3.z.string().describe("The text content of this answer option.")
     })
-  ).min(2).max(6).describe("An array of answer choices that matches the numberOfOptions specified in the input."),
-  correctTempOptionId: import_genkit7.z.string().describe("The temporary ID of the correct option from the generated options array."),
-  explanation: import_genkit7.z.string().optional().describe("A brief explanation of why the answer is correct."),
-  points: import_genkit7.z.number().optional().default(10).describe("Points for a correct answer."),
-  difficulty: import_genkit7.z.enum(["easy", "medium", "hard"]).optional().describe("Assessed difficulty."),
-  topic: import_genkit7.z.string().optional().describe("Refined topic.")
+  ).min(2).max(6),
+  correctTempOptionId: import_zod3.z.string().describe("The temporary ID of the correct option from the generated options array."),
+  explanation: import_zod3.z.string().optional().describe("A brief explanation of why the answer is correct."),
+  points: import_zod3.z.number().optional().default(10).describe("Points for a correct answer."),
+  difficulty: import_zod3.z.enum(["easy", "medium", "hard"]).optional().describe("Assessed difficulty."),
+  topic: import_zod3.z.string().optional().describe("Refined topic.")
 });
-var MultipleChoiceQuestionZodSchema = import_genkit7.z.object({
-  id: import_genkit7.z.string(),
-  questionType: import_genkit7.z.literal("multiple_choice"),
-  prompt: import_genkit7.z.string(),
-  options: import_genkit7.z.array(import_genkit7.z.object({ id: import_genkit7.z.string(), text: import_genkit7.z.string() })),
-  correctAnswerId: import_genkit7.z.string(),
-  points: import_genkit7.z.number().optional(),
-  explanation: import_genkit7.z.string().optional(),
-  learningObjective: import_genkit7.z.string().optional(),
-  glossary: import_genkit7.z.array(import_genkit7.z.string()).optional(),
-  bloomLevel: import_genkit7.z.string().optional(),
-  difficulty: import_genkit7.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: import_genkit7.z.string().optional(),
-  gradeBand: import_genkit7.z.string().optional(),
-  course: import_genkit7.z.string().optional(),
-  category: import_genkit7.z.string().optional(),
-  topic: import_genkit7.z.string().optional()
+var MultipleChoiceQuestionZodSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  questionType: import_zod3.z.literal("multiple_choice"),
+  prompt: import_zod3.z.string().min(1),
+  options: import_zod3.z.array(import_zod3.z.object({ id: import_zod3.z.string(), text: import_zod3.z.string().min(1) })).min(2).max(10),
+  correctAnswerId: import_zod3.z.string(),
+  points: import_zod3.z.number().min(0).optional(),
+  explanation: import_zod3.z.string().optional(),
+  learningObjective: import_zod3.z.string().optional(),
+  glossary: import_zod3.z.array(import_zod3.z.string()).optional(),
+  bloomLevel: import_zod3.z.string().optional(),
+  difficulty: import_zod3.z.enum(["easy", "medium", "hard"]).optional(),
+  contextCode: import_zod3.z.string().optional(),
+  gradeBand: import_zod3.z.string().optional(),
+  course: import_zod3.z.string().optional(),
+  category: import_zod3.z.string().optional(),
+  topic: import_zod3.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"]
 });
-var GenerateMCQQuestionOutputSchema = import_genkit7.z.object({
+var GenerateMCQQuestionOutputSchema = import_zod3.z.object({
   question: MultipleChoiceQuestionZodSchema.optional().describe("The generated Multiple Choice question.")
 });
-async function generateMCQQuestion(input) {
-  return generateMCQQuestionFlow(input);
+async function generateMCQQuestion(clientInput, apiKey) {
+  try {
+    const ai = (0, import_genkit3.genkit)({
+      plugins: [(0, import_googleai3.googleAI)({ apiKey })],
+      model: import_googleai3.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"
 }
-var mcqAIPrompt = ai.definePrompt({
-  name: "mcqQuestionGeneratorPrompt",
-  input: { schema: GenerateMCQQuestionInputSchema },
-  output: { schema: AIMCQOutputFieldsSchema },
-  prompt: `You are an expert quiz question writer.
-Generate a single Multiple Choice question based on the following inputs.
-Provide the question statement (prompt), an array of options (each with a unique temporary ID like 'A', 'B', 'C' or 'option_1', 'option_2' and its text), the temporary ID of the correct option, an optional explanation, optional points (default 10), and optionally refine the topic and difficulty.
-Ensure there are exactly {{{numberOfOptions}}} options. The temporary IDs for options must be unique within the 'options' array and one of them must match 'correctTempOptionId'.
-
-Topic: {{{topic}}}
-{{#if contextDescription}}
-Context: {{{contextDescription}}}
-{{/if}}
-Difficulty: {{{difficulty}}}
-Number of Options: {{{numberOfOptions}}}
-
-Ensure your output strictly matches the requested JSON schema.
-`
-});
-var generateMCQQuestionFlow = ai.defineFlow(
-  {
-    name: "generateMCQQuestionFlow",
-    inputSchema: GenerateMCQQuestionInputSchema,
-    outputSchema: GenerateMCQQuestionOutputSchema
-  },
-  async (input) => {
-    try {
-      const { output: aiGeneratedContent } = await mcqAIPrompt(input);
-      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) {
-          const correctAiOption = aiGeneratedContent.options.find((o) => o.tempId === aiGeneratedContent.correctTempOptionId);
-          if (correctAiOption) {
-          } else {
-            const index = parseInt(aiGeneratedContent.correctTempOptionId);
-            if (!isNaN(index) && index >= 0 && index < finalOptions.length && finalOptions[index].id) {
-            } else {
-              throw new Error(`Correct option ID '${aiGeneratedContent.correctTempOptionId}' is invalid or does not match any generated option tempId.`);
-            }
-          }
-          if (!finalCorrectAnswerId) {
-            throw new Error(`Correct option ID '${aiGeneratedContent.correctTempOptionId}' is invalid or does not match any generated option tempId.`);
-          }
+
+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 };
         }
-        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 || input.topic,
-          difficulty: aiGeneratedContent.difficulty || input.difficulty,
-          learningObjective: void 0,
-          glossary: void 0,
-          bloomLevel: void 0,
-          contextCode: input.contextDescription ? input.selectedContextId : void 0,
-          gradeBand: void 0,
-          course: void 0,
-          category: void 0
-        };
-        return { question: completeQuestion };
-      } else {
-        throw new Error("AI did not return content for the MCQ question.");
+        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.`);
       }
-    } catch (error) {
-      console.error("Error generating MCQ question in flow:", error);
-      throw new Error(`Failed to generate MCQ question: ${error.message}`);
+      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}`);
   }
-);
+}
 
 // src/ai/flows/generate-mrq-question.ts
-var import_genkit9 = require("genkit");
-var GenerateMRQQuestionInputSchema = import_genkit9.z.object({
-  topic: import_genkit9.z.string().describe("The topic for the question."),
-  difficulty: import_genkit9.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfOptions: import_genkit9.z.number().int().min(2).max(8).optional().default(5).describe("Number of answer options to generate (2-8)."),
-  minCorrectAnswers: import_genkit9.z.number().int().min(1).optional().default(2).describe("Minimum number of correct answers among the options."),
-  maxCorrectAnswers: import_genkit9.z.number().int().min(1).optional().default(3).describe("Maximum number of correct answers (must be <= numberOfOptions)."),
-  contextDescription: import_genkit9.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: import_genkit9.z.string().optional().describe("The ID of the selected context, if any.")
+var import_zod4 = require("zod");
+var import_genkit4 = require("genkit");
+var import_googleai4 = require("@genkit-ai/googleai");
+function extractJsonFromMarkdown4(text) {
+  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  return match ? match[1].trim() : text.trim();
+}
+var GenerateMRQQuestionClientInputSchema = import_zod4.z.object({
+  topic: import_zod4.z.string().describe("The topic for the question."),
+  language: import_zod4.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
+  // <-- ĐÃ THÊM
+  difficulty: import_zod4.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  numberOfOptions: import_zod4.z.number().int().min(2).max(8).optional().default(5).describe("Number of answer options to generate (2-8)."),
+  minCorrectAnswers: import_zod4.z.number().int().min(1).optional().default(2).describe("Minimum number of correct answers among the options."),
+  maxCorrectAnswers: import_zod4.z.number().int().min(1).optional().default(3).describe("Maximum number of correct answers (must be <= numberOfOptions)."),
+  contextDescription: import_zod4.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
+  selectedContextId: import_zod4.z.string().optional().describe("The ID of the selected context, if any.")
 });
-var AIMRQOutputFieldsSchema = import_genkit9.z.object({
-  prompt: import_genkit9.z.string().describe("The question statement itself."),
-  options: import_genkit9.z.array(
-    import_genkit9.z.object({
-      tempId: import_genkit9.z.string().describe("A temporary, unique identifier for this option (e.g., 'A', 'B')."),
-      text: import_genkit9.z.string().describe("The text content of this answer option.")
+var AIMRQOutputFieldsSchema = import_zod4.z.object({
+  prompt: import_zod4.z.string().describe("The question statement itself."),
+  options: import_zod4.z.array(
+    import_zod4.z.object({
+      tempId: import_zod4.z.string().describe("A temporary, unique identifier for this option (e.g., 'A', 'B')."),
+      text: import_zod4.z.string().describe("The text content of this answer option.")
     })
-  ).min(2).max(8).describe("An array of answer choices."),
-  correctTempOptionIds: import_genkit9.z.array(import_genkit9.z.string()).min(1).describe("An array of temporary IDs of the correct options from the generated options array."),
-  explanation: import_genkit9.z.string().optional().describe("A brief explanation of why the answers are correct."),
-  points: import_genkit9.z.number().optional().default(10).describe("Points for a correct answer."),
-  difficulty: import_genkit9.z.enum(["easy", "medium", "hard"]).optional().describe("Assessed difficulty."),
-  topic: import_genkit9.z.string().optional().describe("Refined topic.")
+  ).min(2).max(8),
+  correctTempOptionIds: import_zod4.z.array(import_zod4.z.string()).min(1).describe("An array of temporary IDs of the correct options."),
+  explanation: import_zod4.z.string().optional().describe("A brief explanation of why the answers are correct."),
+  points: import_zod4.z.number().optional().default(10).describe("Points for a correct answer."),
+  difficulty: import_zod4.z.enum(["easy", "medium", "hard"]).optional().describe("Assessed difficulty."),
+  topic: import_zod4.z.string().optional().describe("Refined topic.")
 });
-var MultipleResponseQuestionZodSchema = import_genkit9.z.object({
-  id: import_genkit9.z.string(),
-  questionType: import_genkit9.z.literal("multiple_response"),
-  prompt: import_genkit9.z.string(),
-  options: import_genkit9.z.array(import_genkit9.z.object({ id: import_genkit9.z.string(), text: import_genkit9.z.string() })),
-  correctAnswerIds: import_genkit9.z.array(import_genkit9.z.string()),
-  points: import_genkit9.z.number().optional(),
-  explanation: import_genkit9.z.string().optional(),
-  learningObjective: import_genkit9.z.string().optional(),
-  glossary: import_genkit9.z.array(import_genkit9.z.string()).optional(),
-  bloomLevel: import_genkit9.z.string().optional(),
-  difficulty: import_genkit9.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: import_genkit9.z.string().optional(),
-  gradeBand: import_genkit9.z.string().optional(),
-  course: import_genkit9.z.string().optional(),
-  category: import_genkit9.z.string().optional(),
-  topic: import_genkit9.z.string().optional()
+var MultipleResponseQuestionZodSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  questionType: import_zod4.z.literal("multiple_response"),
+  prompt: import_zod4.z.string().min(1),
+  options: import_zod4.z.array(import_zod4.z.object({ id: import_zod4.z.string(), text: import_zod4.z.string().min(1) })).min(2).max(10),
+  correctAnswerIds: import_zod4.z.array(import_zod4.z.string()).min(1),
+  points: import_zod4.z.number().min(0).optional(),
+  explanation: import_zod4.z.string().optional(),
+  learningObjective: import_zod4.z.string().optional(),
+  glossary: import_zod4.z.array(import_zod4.z.string()).optional(),
+  bloomLevel: import_zod4.z.string().optional(),
+  difficulty: import_zod4.z.enum(["easy", "medium", "hard"]).optional(),
+  contextCode: import_zod4.z.string().optional(),
+  gradeBand: import_zod4.z.string().optional(),
+  course: import_zod4.z.string().optional(),
+  category: import_zod4.z.string().optional(),
+  topic: import_zod4.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"]
 });
-var GenerateMRQQuestionOutputSchema = import_genkit9.z.object({
+var GenerateMRQQuestionOutputSchema = import_zod4.z.object({
   question: MultipleResponseQuestionZodSchema.optional().describe("The generated Multiple Response question.")
 });
-async function generateMRQQuestion(input) {
-  if (input.minCorrectAnswers > input.maxCorrectAnswers) {
-    throw new Error("Minimum correct answers cannot exceed maximum correct answers.");
-  }
-  if (input.maxCorrectAnswers > input.numberOfOptions) {
-    throw new Error("Maximum correct answers cannot exceed the total number of options.");
-  }
-  return generateMRQQuestionFlow(input);
+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 = (0, import_genkit4.genkit)({
+      plugins: [(0, import_googleai4.googleAI)({ apiKey })],
+      model: import_googleai4.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"
 }
-var mrqAIPrompt = ai.definePrompt({
-  name: "mrqQuestionGeneratorPrompt",
-  input: { schema: GenerateMRQQuestionInputSchema },
-  output: { schema: AIMRQOutputFieldsSchema },
-  prompt: `You are an expert quiz question writer.
-Generate a single Multiple Response question based on the following inputs.
-Provide the question statement (prompt), an array of options (each with a unique temporary ID and its text), an array of the temporary IDs of the correct options, an optional explanation, optional points (default 10), and optionally refine the topic and difficulty.
-Ensure there are exactly {{{numberOfOptions}}} options.
-Ensure there are between {{{minCorrectAnswers}}} and {{{maxCorrectAnswers}}} correct options.
-The temporary IDs for options must be unique within the 'options' array and all IDs in 'correctTempOptionIds' must match one of them.
-
-Topic: {{{topic}}}
-{{#if contextDescription}}
-Context: {{{contextDescription}}}
-{{/if}}
-Difficulty: {{{difficulty}}}
-Number of Options: {{{numberOfOptions}}}
-Min Correct Answers: {{{minCorrectAnswers}}}
-Max Correct Answers: {{{maxCorrectAnswers}}}
-
-Ensure your output strictly matches the requested JSON schema.
-`
-});
-var generateMRQQuestionFlow = ai.defineFlow(
-  {
-    name: "generateMRQQuestionFlow",
-    inputSchema: GenerateMRQQuestionInputSchema,
-    outputSchema: GenerateMRQQuestionOutputSchema
-  },
-  async (input) => {
-    try {
-      const { output: aiGeneratedContent } = await mrqAIPrompt(input);
-      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 < input.minCorrectAnswers || finalCorrectAnswerIds.length > input.maxCorrectAnswers) {
-          throw new Error(`AI generated ${finalCorrectAnswerIds.length} correct answers, which is outside the requested range of ${input.minCorrectAnswers}-${input.maxCorrectAnswers}.`);
+
+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] };
         }
-        if (finalOptions.length !== input.numberOfOptions) {
-          throw new Error(`AI generated ${finalOptions.length} options, but ${input.numberOfOptions} were requested.`);
+        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.`);
         }
-        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 || input.topic,
-          difficulty: aiGeneratedContent.difficulty || input.difficulty,
-          learningObjective: void 0,
-          glossary: void 0,
-          bloomLevel: void 0,
-          contextCode: input.contextDescription ? input.selectedContextId : void 0,
-          gradeBand: void 0,
-          course: void 0,
-          category: void 0
-        };
-        return { question: completeQuestion };
-      } else {
-        throw new Error("AI did not return content for the MRQ question.");
+        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}.`);
       }
-    } catch (error) {
-      console.error("Error generating MRQ question in flow:", error);
-      throw new Error(`Failed to generate MRQ question: ${error.message}`);
+      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}`);
   }
-);
+}
 
 // src/ai/flows/generate-numeric-question.ts
-var import_genkit11 = require("genkit");
-var GenerateNumericQuestionInputSchema = import_genkit11.z.object({
-  topic: import_genkit11.z.string().describe("The topic for the question."),
-  difficulty: import_genkit11.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  allowDecimals: import_genkit11.z.boolean().optional().default(true).describe("Whether the answer can be a decimal."),
-  minRange: import_genkit11.z.number().optional().describe("Optional minimum value for the answer."),
-  maxRange: import_genkit11.z.number().optional().describe("Optional maximum value for the answer."),
-  contextDescription: import_genkit11.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: import_genkit11.z.string().optional().describe("The ID of the selected context, if any.")
+var import_zod5 = require("zod");
+var import_genkit5 = require("genkit");
+var import_googleai5 = require("@genkit-ai/googleai");
+function extractJsonFromMarkdown5(text) {
+  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  return match ? match[1].trim() : text.trim();
+}
+var GenerateNumericQuestionClientInputSchema = import_zod5.z.object({
+  topic: import_zod5.z.string().describe("The topic for the question."),
+  language: import_zod5.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
+  // <-- ĐÃ THÊM
+  difficulty: import_zod5.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  allowDecimals: import_zod5.z.boolean().optional().default(true).describe("Whether the answer can be a decimal."),
+  minRange: import_zod5.z.number().optional().describe("Optional minimum value for the answer."),
+  maxRange: import_zod5.z.number().optional().describe("Optional maximum value for the answer."),
+  contextDescription: import_zod5.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
+  selectedContextId: import_zod5.z.string().optional().describe("The ID of the selected context, if any.")
 });
-var AINumericOutputFieldsSchema = import_genkit11.z.object({
-  prompt: import_genkit11.z.string().describe("The question statement that expects a numerical answer."),
-  answer: import_genkit11.z.number().describe("The precise numerical correct answer."),
-  tolerance: import_genkit11.z.number().optional().default(0).describe("The acceptable range of error (plus or minus). E.g., if answer is 10 and tolerance is 0.5, answers between 9.5 and 10.5 are correct. Default is 0 for exact match."),
-  explanation: import_genkit11.z.string().optional().describe("Explanation for the correct answer."),
-  points: import_genkit11.z.number().optional().default(10),
-  difficulty: import_genkit11.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: import_genkit11.z.string().optional()
+var AINumericOutputFieldsSchema = import_zod5.z.object({
+  prompt: import_zod5.z.string().describe("The question statement that expects a numerical answer."),
+  answer: import_zod5.z.number().describe("The precise numerical correct answer."),
+  tolerance: import_zod5.z.number().min(0).optional().default(0).describe("The acceptable range of error (plus or minus). Default is 0 for exact match."),
+  explanation: import_zod5.z.string().optional().describe("Explanation for the correct answer."),
+  points: import_zod5.z.number().optional().default(10),
+  difficulty: import_zod5.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: import_zod5.z.string().optional()
 });
-var NumericQuestionZodSchema = import_genkit11.z.object({
-  id: import_genkit11.z.string(),
-  questionType: import_genkit11.z.literal("numeric"),
-  prompt: import_genkit11.z.string(),
-  answer: import_genkit11.z.number(),
-  tolerance: import_genkit11.z.number().optional(),
-  points: import_genkit11.z.number().optional(),
-  explanation: import_genkit11.z.string().optional(),
-  learningObjective: import_genkit11.z.string().optional(),
-  glossary: import_genkit11.z.array(import_genkit11.z.string()).optional(),
-  bloomLevel: import_genkit11.z.string().optional(),
-  difficulty: import_genkit11.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: import_genkit11.z.string().optional(),
-  gradeBand: import_genkit11.z.string().optional(),
-  course: import_genkit11.z.string().optional(),
-  category: import_genkit11.z.string().optional(),
-  topic: import_genkit11.z.string().optional()
+var NumericQuestionZodSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  questionType: import_zod5.z.literal("numeric"),
+  prompt: import_zod5.z.string().min(1),
+  answer: import_zod5.z.number(),
+  tolerance: import_zod5.z.number().min(0).optional(),
+  points: import_zod5.z.number().min(0).optional(),
+  explanation: import_zod5.z.string().optional(),
+  learningObjective: import_zod5.z.string().optional(),
+  glossary: import_zod5.z.array(import_zod5.z.string()).optional(),
+  bloomLevel: import_zod5.z.string().optional(),
+  difficulty: import_zod5.z.enum(["easy", "medium", "hard"]).optional(),
+  contextCode: import_zod5.z.string().optional(),
+  gradeBand: import_zod5.z.string().optional(),
+  course: import_zod5.z.string().optional(),
+  category: import_zod5.z.string().optional(),
+  topic: import_zod5.z.string().optional()
 });
-var GenerateNumericQuestionOutputSchema = import_genkit11.z.object({
+var GenerateNumericQuestionOutputSchema = import_zod5.z.object({
   question: NumericQuestionZodSchema.optional().describe("The generated Numeric question.")
 });
-async function generateNumericQuestion(input) {
-  return generateNumericQuestionFlow(input);
+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 = (0, import_genkit5.genkit)({
+      plugins: [(0, import_googleai5.googleAI)({ apiKey })],
+      model: import_googleai5.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"
 }
-var numericAIPrompt = ai.definePrompt({
-  name: "numericQuestionGeneratorPrompt",
-  input: { schema: GenerateNumericQuestionInputSchema },
-  output: { schema: AINumericOutputFieldsSchema },
-  prompt: `You are an expert quiz question writer.
-Generate a single Numeric question based on the topic and difficulty.
-The question should require a numerical answer.
-Provide the question prompt, the correct numerical answer, an optional tolerance (default 0 for exact match), an optional explanation, points (default 10), and optionally refine the topic/difficulty.
-{{#if minRange}}The answer should ideally be greater than or equal to {{{minRange}}}.{{/if}}
-{{#if maxRange}}The answer should ideally be less than or equal to {{{maxRange}}}.{{/if}}
-The answer should be an integer if 'allowDecimals' is false, otherwise it can be a decimal. Current 'allowDecimals': {{{allowDecimals}}}.
-
-Topic: {{{topic}}}
-{{#if contextDescription}}
-Context: {{{contextDescription}}}
-{{/if}}
-Difficulty: {{{difficulty}}}
-
-Ensure your output strictly matches the requested JSON schema.
-`
-});
-var generateNumericQuestionFlow = ai.defineFlow(
-  {
-    name: "generateNumericQuestionFlow",
-    inputSchema: GenerateNumericQuestionInputSchema,
-    outputSchema: GenerateNumericQuestionOutputSchema
-  },
-  async (input) => {
-    try {
-      const { output: aiGeneratedContent } = await numericAIPrompt(input);
-      if (aiGeneratedContent) {
-        let finalAnswer = aiGeneratedContent.answer;
-        if (!input.allowDecimals) {
-          finalAnswer = Math.round(finalAnswer);
-        }
-        if (input.minRange !== void 0 && finalAnswer < input.minRange) {
-          console.warn(`AI generated answer ${finalAnswer} below minRange ${input.minRange}. Adjusting or re-prompt might be needed for stricter adherence.`);
-        }
-        if (input.maxRange !== void 0 && finalAnswer > input.maxRange) {
-          console.warn(`AI generated answer ${finalAnswer} above maxRange ${input.maxRange}. Adjusting or re-prompt might be needed.`);
-        }
-        const completeQuestion = {
-          id: generateUniqueId("numq_ai_"),
-          questionType: "numeric",
-          prompt: aiGeneratedContent.prompt,
-          answer: finalAnswer,
-          tolerance: aiGeneratedContent.tolerance,
-          explanation: aiGeneratedContent.explanation,
-          points: aiGeneratedContent.points,
-          topic: aiGeneratedContent.topic || input.topic,
-          difficulty: aiGeneratedContent.difficulty || input.difficulty,
-          contextCode: input.contextDescription ? input.selectedContextId : void 0
-        };
-        return { question: completeQuestion };
-      } else {
-        throw new Error("AI did not return content for the Numeric question.");
+
+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);
       }
-    } catch (error) {
-      console.error("Error generating Numeric question in flow:", error);
-      throw new Error(`Failed to generate Numeric question: ${error.message}`);
+      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}`);
   }
-);
+}
 
-// src/ai/flows/generate-quiz-plan-flow.ts
-var import_genkit13 = require("genkit");
+// src/ai/flows/generate-quiz-plan.ts
+var import_zod6 = require("zod");
+var import_genkit6 = require("genkit");
+var import_googleai6 = require("@genkit-ai/googleai");
+function extractJsonFromMarkdown6(text) {
+  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  return match ? match[1].trim() : text.trim();
+}
 var fullQuizSupportedQuestionTypesArray = [
   "true_false",
   "multiple_choice",
@@ -2138,436 +2490,490 @@ var fullQuizSupportedQuestionTypesArray = [
   "numeric",
   "fill_in_the_blanks",
   "sequence",
-  "matching",
-  "drag_and_drop"
+  "matching"
 ];
-var BloomLevelStringsEnum = import_genkit13.z.enum(["remembering", "understanding", "applying"]);
-var GenerateQuizPlanInputSchema = import_genkit13.z.object({
-  totalQuestions: import_genkit13.z.number().int().min(1).max(100).describe("Total number of questions for the quiz (1-100)."),
-  topics: import_genkit13.z.array(
-    import_genkit13.z.object({
-      topic: import_genkit13.z.string().min(1, { message: "Topic name cannot be empty." }).describe("Name of the topic."),
-      ratio: import_genkit13.z.number().min(0).max(100).describe("Percentage of questions for this topic (0-100).")
-    })
-  ).min(1, { message: "At least one topic is required." }).describe("List of topics and their desired percentage distribution."),
-  bloomLevels: import_genkit13.z.array(
-    import_genkit13.z.object({
-      level: BloomLevelStringsEnum.describe("Bloom's taxonomy level."),
-      ratio: import_genkit13.z.number().min(0).max(100).describe("Percentage of questions for this Bloom level (0-100).")
-    })
-  ).min(1, { message: "At least one Bloom level distribution is required." }).describe("Desired distribution of Bloom's levels across the quiz."),
-  selectedContextIds: import_genkit13.z.array(import_genkit13.z.string()).optional().describe('Array of IDs for contexts relevant to the quiz (e.g., "THEO_ABS", "REAL_PROB"). These are hints for the AI.'),
-  selectedQuestionTypes: import_genkit13.z.array(import_genkit13.z.enum(fullQuizSupportedQuestionTypesArray)).min(1, { message: "At least one question type must be selected." }).describe("Array of question types to be used in the quiz. Must not include Hotspot or Blockly types.")
+var BloomLevelStringsEnum = import_zod6.z.enum(["remembering", "understanding", "applying"]);
+var GenerateQuizPlanClientInputSchema = import_zod6.z.object({
+  language: import_zod6.z.string().optional().default("English").describe('The language for the quiz plan (e.g., "Vietnamese", "English").'),
+  // <-- ĐÃ THÊM
+  totalQuestions: import_zod6.z.number().int().min(1).max(50),
+  topics: import_zod6.z.array(import_zod6.z.object({
+    topic: import_zod6.z.string().min(1),
+    ratio: import_zod6.z.number().min(0).max(100)
+  })).min(1),
+  bloomLevels: import_zod6.z.array(import_zod6.z.object({
+    level: BloomLevelStringsEnum,
+    ratio: import_zod6.z.number().min(0).max(100)
+  })).min(1),
+  selectedContextIds: import_zod6.z.array(import_zod6.z.string()).optional(),
+  selectedQuestionTypes: import_zod6.z.array(import_zod6.z.enum(fullQuizSupportedQuestionTypesArray)).min(1)
 });
-var PlannedQuestionSchema = import_genkit13.z.object({
-  plannedTopic: import_genkit13.z.string().describe("The specific topic for this question, derived from the input topics and ratios."),
-  plannedQuestionType: import_genkit13.z.enum(fullQuizSupportedQuestionTypesArray).describe("The specific question type chosen for this question from the allowed types."),
-  plannedBloomLevel: BloomLevelStringsEnum.describe("The Bloom's level assigned to this question based on overall distribution.")
+var PlannedQuestionSchema = import_zod6.z.object({
+  plannedTopic: import_zod6.z.string().min(1).describe("The specific topic for this question."),
+  plannedQuestionType: import_zod6.z.enum(fullQuizSupportedQuestionTypesArray).describe("The specific question type chosen."),
+  plannedBloomLevel: BloomLevelStringsEnum.describe("The Bloom's level assigned.")
 });
-var GenerateQuizPlanOutputSchema = import_genkit13.z.object({
-  quizPlan: import_genkit13.z.array(PlannedQuestionSchema).describe("A detailed plan for each question in the quiz, specifying topic, type, and Bloom level.")
+var GenerateQuizPlanOutputSchema = import_zod6.z.object({
+  quizPlan: import_zod6.z.array(PlannedQuestionSchema).describe("A detailed plan for each question in the quiz.")
 });
-async function generateQuizPlan(input) {
-  const totalTopicRatio = input.topics.reduce((sum, t) => sum + t.ratio, 0);
-  if (Math.abs(totalTopicRatio - 100) > 0.1 && input.topics.length > 0) {
-    throw new Error(`Total topic ratio must be 100%. Current sum: ${totalTopicRatio.toFixed(1)}%`);
-  }
-  const totalBloomRatio = input.bloomLevels.reduce((sum, b) => sum + b.ratio, 0);
-  if (Math.abs(totalBloomRatio - 100) > 0.1) {
-    throw new Error(`Total Bloom level ratio must be 100%. Current sum: ${totalBloomRatio.toFixed(1)}%`);
-  }
-  if (input.totalQuestions <= 0 || input.totalQuestions > 100) {
-    throw new Error("Total questions must be between 1 and 100.");
-  }
-  if (input.selectedQuestionTypes.length === 0) {
-    throw new Error("At least one question type must be selected.");
-  }
-  if (input.selectedQuestionTypes.some((qt) => qt === "hotspot" || qt === "blockly_programming" || qt === "scratch_programming")) {
-    throw new Error("Selected question types must not include Hotspot, Blockly Programming, or Scratch Programming for this flow.");
-  }
-  return generateQuizPlanFlow(input);
-}
-var quizPlannerAIPrompt = ai.definePrompt({
-  name: "quizPlannerAIPrompt",
-  input: { schema: GenerateQuizPlanInputSchema },
-  output: { schema: GenerateQuizPlanOutputSchema },
-  prompt: `You are an expert educational content planner specializing in creating balanced and effective quiz blueprints.
-Your task is to generate a detailed plan for a quiz consisting of exactly {{{totalQuestions}}} questions.
-The plan should be an array of objects, where each object represents one question and specifies its 'plannedTopic', 'plannedQuestionType', and 'plannedBloomLevel'.
+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 = (0, import_genkit6.genkit)({
+      plugins: [(0, import_googleai6.googleAI)({ apiKey })],
+      model: import_googleai6.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}.
 
-Constraints and Guidelines:
-1.  **Total Questions**: The output 'quizPlan' array must contain exactly {{{totalQuestions}}} elements.
-2.  **Topic Distribution**: Distribute the questions across the following topics according to their specified ratios. Aim to match these ratios as closely as possible.
-    {{#each topics}}
-    - Topic: "{{this.topic}}", Ratio: {{this.ratio}}%
-    {{/each}}
-3.  **Bloom Level Distribution**: Distribute the questions across the following Bloom's Taxonomy levels according to their specified ratios. This distribution applies to the entire quiz.
-    {{#each bloomLevels}}
-    - Level: "{{this.level}}", Ratio: {{this.ratio}}%
-    {{/each}}
-4.  **Question Types**: For each planned question, select a 'plannedQuestionType' from the following allowed types: {{#each selectedQuestionTypes}}{{{this}}}{{#unless @last}}, {{/unless}}{{/each}}. Try to use a variety of these selected types throughout the quiz, if appropriate for the topics and Bloom levels. The available types are: ${fullQuizSupportedQuestionTypesArray.map((q) => `'${q}'`).join(", ")}.
-5.  **Contexts (Informational)**: The user has indicated the following general contexts are relevant to the quiz: {{#if selectedContextIds}}{{#each selectedContextIds}}{{{this}}}{{#unless @last}}, {{/unless}}{{/each}}{{else}}None specified{{/if}}. You don't need to explicitly assign a context ID to each planned question in your output, but keep these in mind when deciding on topic nuances or type suitability, if applicable. The actual detailed question generation later will handle context.
-6.  **Output Format**: Ensure your output is a JSON object containing a single key "quizPlan", which is an array of question plan objects. Each question plan object must have "plannedTopic" (string), "plannedQuestionType" (one of the allowed enum values specified in guideline 4), and "plannedBloomLevel" (one of the allowed enum values: 'remembering', 'understanding', 'applying').
-
-Example of a single element in the 'quizPlan' array:
+IMPORTANT: Return the response as JSON with this EXACT format:
 {
-  "plannedTopic": "Cellular Respiration Stages",
-  "plannedQuestionType": "multiple_choice",
-  "plannedBloomLevel": "understanding"
+  "quizPlan": [
+    { "plannedTopic": "Specific Topic A", "plannedQuestionType": "multiple_choice", "plannedBloomLevel": "remembering" },
+    { "plannedTopic": "Specific Topic B", "plannedQuestionType": "true_false", "plannedBloomLevel": "understanding" }
+  ]
 }
 
-Carefully calculate the number of questions for each topic and Bloom level based on the total number of questions and the provided ratios. Strive for a balanced and logical distribution.
-If ratios lead to fractional questions, round to the nearest whole number in a way that maintains the total number of questions.
-The 'plannedTopic' for each question should be specific and directly related to one of the user-provided topics.
-The final 'quizPlan' array must have exactly {{{totalQuestions}}} elements.
-`
-});
-var generateQuizPlanFlow = ai.defineFlow(
-  {
-    name: "generateQuizPlanFlow",
-    inputSchema: GenerateQuizPlanInputSchema,
-    outputSchema: GenerateQuizPlanOutputSchema
-  },
-  async (input) => {
-    try {
-      const { output } = await quizPlannerAIPrompt(input);
-      if (!output || !output.quizPlan) {
-        throw new Error("AI did not return a quiz plan.");
-      }
-      if (output.quizPlan.length !== input.totalQuestions) {
-        console.warn(`AI generated a plan for ${output.quizPlan.length} questions, but ${input.totalQuestions} were requested. This is an error in AI adherence.`);
-        throw new Error(`AI planned for ${output.quizPlan.length} questions, but ${input.totalQuestions} were requested. The plan must match the total number of questions.`);
+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 = extractJsonFromMarkdown6(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}'`);
       }
-      output.quizPlan.forEach((item, index) => {
-        if (!input.selectedQuestionTypes.includes(item.plannedQuestionType)) {
-          throw new Error(`AI planned question ${index + 1} with an invalid or disallowed question type: ${item.plannedQuestionType}`);
-        }
-        const validBloomLevels = ["remembering", "understanding", "applying"];
-        if (!validBloomLevels.includes(item.plannedBloomLevel)) {
-          throw new Error(`AI planned question ${index + 1} with an invalid Bloom level: ${item.plannedBloomLevel}`);
-        }
-        if (!input.topics.some((t) => t.topic === item.plannedTopic)) {
-          console.warn(`AI planned question ${index + 1} with topic "${item.plannedTopic}" which was not in the input topics. This might be an AI interpretation or error.`);
-        }
-      });
-      return output;
-    } catch (error) {
-      console.error("Error generating Quiz Plan in flow:", error);
-      throw new Error(`Failed to generate Quiz Plan: ${error.message}`);
+    });
+    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}`);
   }
-);
+}
 
 // src/ai/flows/generate-sequence-question.ts
-var import_genkit15 = require("genkit");
-var GenerateSequenceQuestionInputSchema = import_genkit15.z.object({
-  topic: import_genkit15.z.string().describe("The topic for the question."),
-  difficulty: import_genkit15.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfItems: import_genkit15.z.number().int().min(2).max(10).optional().default(4).describe("Number of items to sequence (2-10)."),
-  contextDescription: import_genkit15.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: import_genkit15.z.string().optional().describe("The ID of the selected context, if any.")
+var import_zod7 = require("zod");
+var import_genkit7 = require("genkit");
+var import_googleai7 = require("@genkit-ai/googleai");
+function extractJsonFromMarkdown7(text) {
+  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  return match ? match[1].trim() : text.trim();
+}
+var GenerateSequenceQuestionClientInputSchema = import_zod7.z.object({
+  topic: import_zod7.z.string().describe("The topic for the question."),
+  language: import_zod7.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
+  // <-- ĐÃ THÊM
+  difficulty: import_zod7.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  numberOfItems: import_zod7.z.number().int().min(2).max(10).optional().default(4).describe("Number of items to sequence (2-10)."),
+  contextDescription: import_zod7.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
+  selectedContextId: import_zod7.z.string().optional().describe("The ID of the selected context, if any.")
 });
-var AISequenceOutputFieldsSchema = import_genkit15.z.object({
-  prompt: import_genkit15.z.string().describe("The instruction for sequencing (e.g., 'Arrange the following steps in chronological order.')."),
-  itemsContent: import_genkit15.z.array(import_genkit15.z.string()).min(2).describe("An array of strings, where each string is the content of an item to be sequenced. The order here can be random or pre-sorted by AI, it doesn't matter for this field."),
-  correctOrderContent: import_genkit15.z.array(import_genkit15.z.string()).min(2).describe("An array of strings representing the content of the items in the correct sequence. Each string here MUST match one of the strings in 'itemsContent'."),
-  explanation: import_genkit15.z.string().optional().describe("Explanation for the correct sequence."),
-  points: import_genkit15.z.number().optional().default(10),
-  difficulty: import_genkit15.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: import_genkit15.z.string().optional()
+var AISequenceOutputFieldsSchema = import_zod7.z.object({
+  prompt: import_zod7.z.string().describe("The instruction for sequencing."),
+  itemsContent: import_zod7.z.array(import_zod7.z.string().min(1)).min(2).describe("An array of strings for each item to be sequenced."),
+  correctOrderContent: import_zod7.z.array(import_zod7.z.string().min(1)).min(2).describe("An array of the same strings from 'itemsContent', but in the correct sequence."),
+  explanation: import_zod7.z.string().optional().describe("Explanation for the correct sequence."),
+  points: import_zod7.z.number().optional().default(10),
+  difficulty: import_zod7.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: import_zod7.z.string().optional()
 });
-var SequenceQuestionZodSchema = import_genkit15.z.object({
-  id: import_genkit15.z.string(),
-  questionType: import_genkit15.z.literal("sequence"),
-  prompt: import_genkit15.z.string(),
-  items: import_genkit15.z.array(import_genkit15.z.object({ id: import_genkit15.z.string(), content: import_genkit15.z.string() })),
-  correctOrder: import_genkit15.z.array(import_genkit15.z.string()),
+var SequenceQuestionZodSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  questionType: import_zod7.z.literal("sequence"),
+  prompt: import_zod7.z.string().min(1),
+  items: import_zod7.z.array(import_zod7.z.object({ id: import_zod7.z.string(), content: import_zod7.z.string().min(1) })).min(2),
+  correctOrder: import_zod7.z.array(import_zod7.z.string()).min(2),
   // Array of item IDs
-  points: import_genkit15.z.number().optional(),
-  explanation: import_genkit15.z.string().optional(),
-  learningObjective: import_genkit15.z.string().optional(),
-  glossary: import_genkit15.z.array(import_genkit15.z.string()).optional(),
-  bloomLevel: import_genkit15.z.string().optional(),
-  difficulty: import_genkit15.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: import_genkit15.z.string().optional(),
-  gradeBand: import_genkit15.z.string().optional(),
-  course: import_genkit15.z.string().optional(),
-  category: import_genkit15.z.string().optional(),
-  topic: import_genkit15.z.string().optional()
+  points: import_zod7.z.number().min(0).optional(),
+  explanation: import_zod7.z.string().optional(),
+  learningObjective: import_zod7.z.string().optional(),
+  glossary: import_zod7.z.array(import_zod7.z.string()).optional(),
+  bloomLevel: import_zod7.z.string().optional(),
+  difficulty: import_zod7.z.enum(["easy", "medium", "hard"]).optional(),
+  contextCode: import_zod7.z.string().optional(),
+  gradeBand: import_zod7.z.string().optional(),
+  course: import_zod7.z.string().optional(),
+  category: import_zod7.z.string().optional(),
+  topic: import_zod7.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"]
 });
-var GenerateSequenceQuestionOutputSchema = import_genkit15.z.object({
+var GenerateSequenceQuestionOutputSchema = import_zod7.z.object({
   question: SequenceQuestionZodSchema.optional().describe("The generated Sequence question.")
 });
-async function generateSequenceQuestion(input) {
-  return generateSequenceQuestionFlow(input);
+async function generateSequenceQuestion(clientInput, apiKey) {
+  try {
+    const ai = (0, import_genkit7.genkit)({
+      plugins: [(0, import_googleai7.googleAI)({ apiKey })],
+      model: import_googleai7.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"
 }
-var sequenceAIPrompt = ai.definePrompt({
-  name: "sequenceQuestionGeneratorPrompt",
-  input: { schema: GenerateSequenceQuestionInputSchema },
-  output: { schema: AISequenceOutputFieldsSchema },
-  prompt: `You are an expert quiz question writer.
-Generate a single Sequence question with exactly {{{numberOfItems}}} items to be ordered.
-Provide:
-1.  A 'prompt' or instruction.
-2.  An 'itemsContent' array: strings for each item (e.g., ["Event A", "Event B", "Event C"]). The order here doesn't matter yet.
-3.  A 'correctOrderContent' array: strings from 'itemsContent' but in the correct sequence.
-4.  Optional 'explanation', 'points' (default 10), refined 'topic', and 'difficulty'.
-
-Topic: {{{topic}}}
-{{#if contextDescription}}
-Context: {{{contextDescription}}}
-{{/if}}
-Difficulty: {{{difficulty}}}
-Number of Items: {{{numberOfItems}}}
-
-Ensure 'itemsContent' and 'correctOrderContent' contain the same set of strings, and 'correctOrderContent' has exactly {{{numberOfItems}}} elements.
-Ensure your output strictly matches the requested JSON schema.
-`
-});
-var generateSequenceQuestionFlow = ai.defineFlow(
-  {
-    name: "generateSequenceQuestionFlow",
-    inputSchema: GenerateSequenceQuestionInputSchema,
-    outputSchema: GenerateSequenceQuestionOutputSchema
-  },
-  async (input) => {
-    try {
-      const { output: aiGeneratedContent } = await sequenceAIPrompt(input);
-      if (aiGeneratedContent) {
-        if (aiGeneratedContent.itemsContent.length !== input.numberOfItems || aiGeneratedContent.correctOrderContent.length !== input.numberOfItems) {
-          throw new Error(`AI generated ${aiGeneratedContent.itemsContent.length} itemsContent and ${aiGeneratedContent.correctOrderContent.length} correctOrderContent, but ${input.numberOfItems} were requested.`);
-        }
-        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}" in 'correctOrderContent' does not match any content in 'itemsContent'.`);
-          }
-          return id;
-        });
-        if (new Set(finalCorrectOrder).size !== finalItems.length) {
-          throw new Error("Correct order does not contain all items from itemsContent uniquely or items are missing/duplicated.");
+
+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 = extractJsonFromMarkdown7(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'.`);
         }
-        const completeQuestion = {
-          id: generateUniqueId("seq_ai_"),
-          questionType: "sequence",
-          prompt: aiGeneratedContent.prompt,
-          items: finalItems,
-          correctOrder: finalCorrectOrder,
-          explanation: aiGeneratedContent.explanation,
-          points: aiGeneratedContent.points,
-          topic: aiGeneratedContent.topic || input.topic,
-          difficulty: aiGeneratedContent.difficulty || input.difficulty,
-          contextCode: input.contextDescription ? input.selectedContextId : void 0
-        };
-        return { question: completeQuestion };
-      } else {
-        throw new Error("AI did not return content for the Sequence question.");
+        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}`);
       }
-    } catch (error) {
-      console.error("Error generating Sequence question in flow:", error);
-      throw new Error(`Failed to generate Sequence question: ${error.message}`);
+    } 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}`);
   }
-);
+}
 
 // src/ai/flows/generate-short-answer-question.ts
-var import_genkit17 = require("genkit");
-var GenerateShortAnswerQuestionInputSchema = import_genkit17.z.object({
-  topic: import_genkit17.z.string().describe("The topic for the question."),
-  difficulty: import_genkit17.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  isCaseSensitive: import_genkit17.z.boolean().optional().default(false).describe("Whether the answer should be case-sensitive."),
-  contextDescription: import_genkit17.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: import_genkit17.z.string().optional().describe("The ID of the selected context, if any.")
+var import_zod8 = require("zod");
+var import_genkit8 = require("genkit");
+var import_googleai8 = require("@genkit-ai/googleai");
+function extractJsonFromMarkdown8(text) {
+  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  return match ? match[1].trim() : text.trim();
+}
+var GenerateShortAnswerQuestionClientInputSchema = import_zod8.z.object({
+  topic: import_zod8.z.string().describe("The topic for the question."),
+  language: import_zod8.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
+  // <-- ĐÃ THÊM
+  difficulty: import_zod8.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  isCaseSensitive: import_zod8.z.boolean().optional().default(false).describe("Whether the answer should be case-sensitive."),
+  contextDescription: import_zod8.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
+  selectedContextId: import_zod8.z.string().optional().describe("The ID of the selected context, if any.")
 });
-var AIShortAnswerOutputFieldsSchema = import_genkit17.z.object({
-  prompt: import_genkit17.z.string().describe("The question statement."),
-  acceptedAnswers: import_genkit17.z.array(import_genkit17.z.string()).min(1).describe("An array of acceptable short answers. Provide variations if appropriate."),
-  isCaseSensitive: import_genkit17.z.boolean().optional().describe("Should the answer evaluation be case sensitive? Defaults to input or false."),
-  explanation: import_genkit17.z.string().optional().describe("Explanation for the correct answer(s)."),
-  points: import_genkit17.z.number().optional().default(10),
-  difficulty: import_genkit17.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: import_genkit17.z.string().optional()
+var AIShortAnswerOutputFieldsSchema = import_zod8.z.object({
+  prompt: import_zod8.z.string().describe("The question statement."),
+  acceptedAnswers: import_zod8.z.array(import_zod8.z.string().min(1)).min(1).describe("An array of acceptable short answers."),
+  isCaseSensitive: import_zod8.z.boolean().optional().describe("Should the answer evaluation be case sensitive?"),
+  explanation: import_zod8.z.string().optional().describe("Explanation for the correct answer(s)."),
+  points: import_zod8.z.number().optional().default(10),
+  difficulty: import_zod8.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: import_zod8.z.string().optional()
 });
-var ShortAnswerQuestionZodSchema = import_genkit17.z.object({
-  id: import_genkit17.z.string(),
-  questionType: import_genkit17.z.literal("short_answer"),
-  prompt: import_genkit17.z.string(),
-  acceptedAnswers: import_genkit17.z.array(import_genkit17.z.string()),
-  isCaseSensitive: import_genkit17.z.boolean().optional(),
-  points: import_genkit17.z.number().optional(),
-  explanation: import_genkit17.z.string().optional(),
-  learningObjective: import_genkit17.z.string().optional(),
-  glossary: import_genkit17.z.array(import_genkit17.z.string()).optional(),
-  bloomLevel: import_genkit17.z.string().optional(),
-  difficulty: import_genkit17.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: import_genkit17.z.string().optional(),
-  gradeBand: import_genkit17.z.string().optional(),
-  course: import_genkit17.z.string().optional(),
-  category: import_genkit17.z.string().optional(),
-  topic: import_genkit17.z.string().optional()
+var ShortAnswerQuestionZodSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  questionType: import_zod8.z.literal("short_answer"),
+  prompt: import_zod8.z.string().min(1),
+  acceptedAnswers: import_zod8.z.array(import_zod8.z.string().min(1)).min(1),
+  isCaseSensitive: import_zod8.z.boolean().optional(),
+  points: import_zod8.z.number().min(0).optional(),
+  explanation: import_zod8.z.string().optional(),
+  learningObjective: import_zod8.z.string().optional(),
+  glossary: import_zod8.z.array(import_zod8.z.string()).optional(),
+  bloomLevel: import_zod8.z.string().optional(),
+  difficulty: import_zod8.z.enum(["easy", "medium", "hard"]).optional(),
+  contextCode: import_zod8.z.string().optional(),
+  gradeBand: import_zod8.z.string().optional(),
+  course: import_zod8.z.string().optional(),
+  category: import_zod8.z.string().optional(),
+  topic: import_zod8.z.string().optional()
 });
-var GenerateShortAnswerQuestionOutputSchema = import_genkit17.z.object({
+var GenerateShortAnswerQuestionOutputSchema = import_zod8.z.object({
   question: ShortAnswerQuestionZodSchema.optional().describe("The generated Short Answer question.")
 });
-async function generateShortAnswerQuestion(input) {
-  return generateShortAnswerQuestionFlow(input);
+async function generateShortAnswerQuestion(clientInput, apiKey) {
+  var _a;
+  try {
+    const ai = (0, import_genkit8.genkit)({
+      plugins: [(0, import_googleai8.googleAI)({ apiKey })],
+      model: import_googleai8.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"
 }
-var shortAnswerAIPrompt = ai.definePrompt({
-  name: "shortAnswerQuestionGeneratorPrompt",
-  input: { schema: GenerateShortAnswerQuestionInputSchema },
-  output: { schema: AIShortAnswerOutputFieldsSchema },
-  prompt: `You are an expert quiz question writer.
-Generate a single Short Answer question based on the following inputs.
-Provide the question prompt, an array of accepted answer strings, and specify if case sensitivity is important (default to {{{isCaseSensitive}}}).
-Also include an optional explanation, points (default 10), and optionally refine the topic/difficulty.
-
-Topic: {{{topic}}}
-{{#if contextDescription}}
-Context: {{{contextDescription}}}
-{{/if}}
-Difficulty: {{{difficulty}}}
-Case Sensitive: {{{isCaseSensitive}}}
-
-Ensure your output strictly matches the requested JSON schema.
-`
-});
-var generateShortAnswerQuestionFlow = ai.defineFlow(
-  {
-    name: "generateShortAnswerQuestionFlow",
-    inputSchema: GenerateShortAnswerQuestionInputSchema,
-    outputSchema: GenerateShortAnswerQuestionOutputSchema
-  },
-  async (input) => {
-    try {
-      const { output: aiGeneratedContent } = await shortAnswerAIPrompt(input);
-      if (aiGeneratedContent) {
-        const completeQuestion = {
-          id: generateUniqueId("saq_ai_"),
-          questionType: "short_answer",
-          prompt: aiGeneratedContent.prompt,
-          acceptedAnswers: aiGeneratedContent.acceptedAnswers,
-          isCaseSensitive: aiGeneratedContent.isCaseSensitive === void 0 ? input.isCaseSensitive : aiGeneratedContent.isCaseSensitive,
-          explanation: aiGeneratedContent.explanation,
-          points: aiGeneratedContent.points,
-          topic: aiGeneratedContent.topic || input.topic,
-          difficulty: aiGeneratedContent.difficulty || input.difficulty,
-          contextCode: input.contextDescription ? input.selectedContextId : void 0
-        };
-        return { question: completeQuestion };
-      } else {
-        throw new Error("AI did not return content for the Short Answer question.");
+
+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 = extractJsonFromMarkdown8(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}`);
       }
-    } catch (error) {
-      console.error("Error generating Short Answer question in flow:", error);
-      throw new Error(`Failed to generate Short Answer question: ${error.message}`);
+    } 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}`);
   }
-);
+}
 
 // src/ai/flows/generate-true-false-question.ts
-var import_genkit19 = require("genkit");
-var GenerateTrueFalseQuestionInputSchema = import_genkit19.z.object({
-  topic: import_genkit19.z.string().describe("The topic for which to generate a True/False question."),
-  difficulty: import_genkit19.z.enum(["easy", "medium", "hard"]).optional().default("medium").describe("The difficulty level of the question (optional)."),
-  contextDescription: import_genkit19.z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: import_genkit19.z.string().optional().describe("The ID of the selected context, if any.")
+var import_zod9 = require("zod");
+var import_genkit9 = require("genkit");
+var import_googleai9 = require("@genkit-ai/googleai");
+function extractJsonFromMarkdown9(text) {
+  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  return match ? match[1].trim() : text.trim();
+}
+var GenerateTrueFalseQuestionClientInputSchema = import_zod9.z.object({
+  topic: import_zod9.z.string().describe("The topic for the question."),
+  language: import_zod9.z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
+  // <-- ĐÃ THÊM
+  difficulty: import_zod9.z.enum(["easy", "medium", "hard"]).optional().default("medium"),
+  contextDescription: import_zod9.z.string().optional().describe("A specific context or scenario for the question."),
+  selectedContextId: import_zod9.z.string().optional().describe("The ID of the selected context.")
 });
-var AIQuestionOutputFieldsSchema = import_genkit19.z.object({
-  prompt: import_genkit19.z.string().describe("The question text itself. This is the statement to be evaluated as true or false."),
-  correctAnswer: import_genkit19.z.boolean().describe("The correct answer for the statement (true if the statement is true, false if it is false)."),
-  explanation: import_genkit19.z.string().optional().describe("A brief explanation of why the answer is correct."),
-  points: import_genkit19.z.number().optional().default(10).describe("Points awarded for a correct answer. Defaults to 10."),
-  difficulty: import_genkit19.z.enum(["easy", "medium", "hard"]).optional().describe("The assessed difficulty of the generated question."),
-  topic: import_genkit19.z.string().optional().describe("The specific topic of the generated question, potentially refined from the input topic.")
+var AITrueFalseOutputFieldsSchema = import_zod9.z.object({
+  prompt: import_zod9.z.string().describe("The statement to be evaluated as true or false."),
+  correctAnswer: import_zod9.z.boolean().describe("The correct answer (true or false)."),
+  explanation: import_zod9.z.string().optional().describe("A brief explanation of why the answer is correct."),
+  points: import_zod9.z.number().optional().default(10),
+  difficulty: import_zod9.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: import_zod9.z.string().optional()
 });
-var TrueFalseQuestionZodSchema = import_genkit19.z.object({
-  id: import_genkit19.z.string(),
-  questionType: import_genkit19.z.literal("true_false"),
-  prompt: import_genkit19.z.string(),
-  correctAnswer: import_genkit19.z.boolean(),
-  points: import_genkit19.z.number().optional(),
-  explanation: import_genkit19.z.string().optional(),
-  learningObjective: import_genkit19.z.string().optional(),
-  glossary: import_genkit19.z.array(import_genkit19.z.string()).optional(),
-  bloomLevel: import_genkit19.z.string().optional(),
-  difficulty: import_genkit19.z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: import_genkit19.z.string().optional(),
-  gradeBand: import_genkit19.z.string().optional(),
-  course: import_genkit19.z.string().optional(),
-  category: import_genkit19.z.string().optional(),
-  topic: import_genkit19.z.string().optional()
+var TrueFalseQuestionZodSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  questionType: import_zod9.z.literal("true_false"),
+  prompt: import_zod9.z.string().min(1),
+  correctAnswer: import_zod9.z.boolean(),
+  points: import_zod9.z.number().min(0).optional(),
+  explanation: import_zod9.z.string().optional(),
+  learningObjective: import_zod9.z.string().optional(),
+  glossary: import_zod9.z.array(import_zod9.z.string()).optional(),
+  bloomLevel: import_zod9.z.string().optional(),
+  difficulty: import_zod9.z.enum(["easy", "medium", "hard"]).optional(),
+  contextCode: import_zod9.z.string().optional(),
+  gradeBand: import_zod9.z.string().optional(),
+  course: import_zod9.z.string().optional(),
+  category: import_zod9.z.string().optional(),
+  topic: import_zod9.z.string().optional()
 });
-var GenerateTrueFalseQuestionOutputSchema = import_genkit19.z.object({
+var GenerateTrueFalseQuestionOutputSchema = import_zod9.z.object({
   question: TrueFalseQuestionZodSchema.optional().describe("The generated True/False question.")
 });
-async function generateTrueFalseQuestion(input) {
-  return generateTrueFalseQuestionFlow(input);
+async function generateTrueFalseQuestion(clientInput, apiKey) {
+  try {
+    const ai = (0, import_genkit9.genkit)({
+      plugins: [(0, import_googleai9.googleAI)({ apiKey })],
+      model: import_googleai9.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"
 }
-var trueFalseAIPrompt = ai.definePrompt({
-  name: "trueFalseQuestionGeneratorPrompt",
-  input: { schema: GenerateTrueFalseQuestionInputSchema },
-  output: { schema: AIQuestionOutputFieldsSchema },
-  prompt: `You are an expert quiz question writer.
-Generate a single True/False question based on the following inputs.
-The question should be a statement that can be clearly evaluated as true or false.
-Provide the question statement (prompt), the correct answer (true or false), an optional explanation, optional points (default to 10), and optionally refine the topic and difficulty.
-
-Topic: {{{topic}}}
-{{#if contextDescription}}
-Context: {{{contextDescription}}}
-{{/if}}
-Difficulty: {{{difficulty}}}
-
-Ensure your output strictly matches the requested JSON schema.
-`
-});
-var generateTrueFalseQuestionFlow = ai.defineFlow(
-  {
-    name: "generateTrueFalseQuestionFlow",
-    inputSchema: GenerateTrueFalseQuestionInputSchema,
-    outputSchema: GenerateTrueFalseQuestionOutputSchema
-  },
-  async (input) => {
-    try {
-      const { output: aiGeneratedContent } = await trueFalseAIPrompt(input);
-      if (aiGeneratedContent) {
-        const completeQuestion = {
-          prompt: aiGeneratedContent.prompt,
-          correctAnswer: aiGeneratedContent.correctAnswer,
-          explanation: aiGeneratedContent.explanation,
-          points: aiGeneratedContent.points,
-          topic: aiGeneratedContent.topic || input.topic,
-          difficulty: aiGeneratedContent.difficulty || input.difficulty,
-          id: generateUniqueId("tf_ai_"),
-          questionType: "true_false",
-          learningObjective: void 0,
-          glossary: void 0,
-          bloomLevel: void 0,
-          contextCode: input.contextDescription ? input.selectedContextId : void 0,
-          gradeBand: void 0,
-          course: void 0,
-          category: void 0
-        };
-        return { question: completeQuestion };
-      } else {
-        throw new Error("AI did not return content for the question.");
+
+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 = extractJsonFromMarkdown9(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}`);
       }
-    } catch (error) {
-      console.error("Error generating True/False question in flow:", error);
-      throw new Error(`Failed to generate True/False question: ${error.message}`);
+    } 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}`);
   }
-);
+}
 
-// src/ai/flows/generateQuestionsFromQuizPlanFlow.ts
-var import_genkit21 = require("genkit");
+// src/ai/flows/generate-questions-from-quiz-plan.ts
+var import_zod10 = require("zod");
 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" },
@@ -2579,38 +2985,6 @@ var internalContextOptions = [
   { contextId: "INTERDISC", contextDescription: "Li\xEAn ng\xE0nh (Interdisciplinary)" },
   { contextId: "HYPO_COMP", contextDescription: "Gi\u1EA3 \u0111\u1ECBnh/So s\xE1nh T\xECnh hu\u1ED1ng" }
 ];
-var LocalBloomLevelStringsEnum = import_genkit21.z.enum(["remembering", "understanding", "applying"]);
-var fullQuizSupportedQuestionTypesArrayForSchema = [
-  "true_false",
-  "multiple_choice",
-  "multiple_response",
-  "short_answer",
-  "numeric",
-  "fill_in_the_blanks",
-  "sequence",
-  "matching",
-  "drag_and_drop"
-];
-var LocalPlannedQuestionSchema = import_genkit21.z.object({
-  plannedTopic: import_genkit21.z.string().describe("The specific topic for this question, derived from the input topics and ratios."),
-  plannedQuestionType: import_genkit21.z.enum(fullQuizSupportedQuestionTypesArrayForSchema).describe("The specific question type chosen for this question from the allowed types."),
-  plannedBloomLevel: LocalBloomLevelStringsEnum.describe("The Bloom's level assigned to this question based on overall distribution.")
-});
-var GenerateQuestionsFromQuizPlanInputSchema = import_genkit21.z.object({
-  quizPlan: import_genkit21.z.array(LocalPlannedQuestionSchema).describe("The plan for each question, from Stage 1."),
-  selectedContextIds: import_genkit21.z.array(import_genkit21.z.string()).optional().describe("Array of IDs for contexts relevant to the overall quiz."),
-  customContextInput: import_genkit21.z.string().optional().describe("Custom context description if provided by the user.")
-});
-var GenerationErrorSchema = import_genkit21.z.object({
-  plannedQuestionIndex: import_genkit21.z.number().describe("Index of the question in the plan that failed."),
-  plannedTopic: import_genkit21.z.string(),
-  plannedQuestionType: import_genkit21.z.string(),
-  error: import_genkit21.z.string().describe("Error message for this specific question generation.")
-});
-var GenerateQuestionsFromQuizPlanOutputSchema = import_genkit21.z.object({
-  generatedQuestions: import_genkit21.z.array(import_genkit21.z.custom((val) => typeof val === "object" && val !== null && "id" in val && "questionType" in val)).describe("Array of successfully generated QuizQuestion objects."),
-  errors: import_genkit21.z.array(GenerationErrorSchema).optional().describe("Array of errors encountered during generation for specific planned questions.")
-});
 var calculateCombinedDifficulty = (contextId, bloomLevel, qType, generalCustomContextInput) => {
   let contextScore = 1;
   const selectedContext = contextId ? internalContextOptions.find((c) => c.contextId === contextId) : void 0;
@@ -2618,7 +2992,7 @@ var calculateCombinedDifficulty = (contextId, bloomLevel, qType, generalCustomCo
     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 && generalCustomContextInput.trim()) {
+  } else if (generalCustomContextInput == null ? void 0 : generalCustomContextInput.trim()) {
     contextScore = 2;
   }
   let bloomScore = 1;
@@ -2649,31 +3023,50 @@ var calculateCombinedDifficulty = (contextId, bloomLevel, qType, generalCustomCo
   if (totalScore <= 6) return "medium";
   return "hard";
 };
-async function generateQuestionsFromQuizPlan(input) {
-  return generateQuestionsFromQuizPlanFlow(input);
-}
-var generateQuestionsFromQuizPlanFlow = ai.defineFlow(
-  {
-    name: "generateQuestionsFromQuizPlanFlow",
-    inputSchema: GenerateQuestionsFromQuizPlanInputSchema,
-    outputSchema: GenerateQuestionsFromQuizPlanOutputSchema
-  },
-  async ({ quizPlan, selectedContextIds, customContextInput }) => {
-    var _a, _b;
-    const generatedQuestions = [];
-    const errors = [];
-    for (let i = 0; i < quizPlan.length; i++) {
-      const plannedQ = quizPlan[i];
-      let question = void 0;
-      let generationError = null;
-      let contextDescriptionForAI = void 0;
+var PlannedQuestionSchema2 = import_zod10.z.object({
+  plannedTopic: import_zod10.z.string().min(1),
+  plannedQuestionType: import_zod10.z.string(),
+  // Giữ dạng string để linh hoạt, sẽ kiểm tra trong logic
+  plannedBloomLevel: import_zod10.z.enum(["remembering", "understanding", "applying"]),
+  plannedContextId: import_zod10.z.string().optional()
+});
+var GenerateQuestionsFromQuizPlanClientInputSchema = import_zod10.z.object({
+  quizPlan: import_zod10.z.array(PlannedQuestionSchema2).min(1),
+  language: import_zod10.z.string().optional().default("English").describe("The language for the generated questions."),
+  // <-- ĐÃ THÊM
+  selectedContextIds: import_zod10.z.array(import_zod10.z.string()).optional(),
+  customContextInput: import_zod10.z.string().optional()
+});
+var GenerationErrorSchema = import_zod10.z.object({
+  plannedQuestionIndex: import_zod10.z.number(),
+  plannedTopic: import_zod10.z.string(),
+  plannedQuestionType: import_zod10.z.string(),
+  error: import_zod10.z.string()
+});
+var GenerateQuestionsFromQuizPlanOutputSchema = import_zod10.z.object({
+  generatedQuestions: import_zod10.z.array(import_zod10.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: import_zod10.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 (selectedContextIds && selectedContextIds.length > 0 && selectedContextIds[0] !== "__custom__") {
+      } 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 && customContextInput.trim()) {
+      } else if (customContextInput == null ? void 0 : customContextInput.trim()) {
         contextDescriptionForAI = customContextInput.trim();
         if (!contextIdForDifficultyCalc) contextIdForDifficultyCalc = "__custom__";
       }
@@ -2683,71 +3076,69 @@ var generateQuestionsFromQuizPlanFlow = ai.defineFlow(
         plannedQ.plannedQuestionType,
         contextDescriptionForAI
       );
-      const baseQuestionInput = {
+      const baseClientInput = {
         topic: plannedQ.plannedTopic,
+        language,
+        // <-- TRUYỀN `language` VÀO
         difficulty: difficultyForAI,
         contextDescription: contextDescriptionForAI,
-        selectedContextId: plannedQ.plannedContextId
+        selectedContextId: plannedQ.plannedContextId || contextIdForDifficultyCalc
       };
-      try {
-        switch (plannedQ.plannedQuestionType) {
-          case "true_false":
-            ({ question } = await generateTrueFalseQuestion(baseQuestionInput));
-            break;
-          case "multiple_choice":
-            ({ question } = await generateMCQQuestion(__spreadProps(__spreadValues({}, baseQuestionInput), { numberOfOptions: 4 })));
-            break;
-          case "multiple_response":
-            ({ question } = await generateMRQQuestion(__spreadProps(__spreadValues({}, baseQuestionInput), { numberOfOptions: 5, minCorrectAnswers: 2, maxCorrectAnswers: 3 })));
-            break;
-          case "short_answer":
-            ({ question } = await generateShortAnswerQuestion(__spreadProps(__spreadValues({}, baseQuestionInput), { isCaseSensitive: false })));
-            break;
-          case "numeric":
-            ({ question } = await generateNumericQuestion(__spreadProps(__spreadValues({}, baseQuestionInput), { allowDecimals: true })));
-            break;
-          case "fill_in_the_blanks":
-            ({ question } = await generateFillInTheBlanksQuestion(__spreadProps(__spreadValues({}, baseQuestionInput), { numberOfBlanks: 2, isCaseSensitive: false })));
-            break;
-          case "sequence":
-            ({ question } = await generateSequenceQuestion(__spreadProps(__spreadValues({}, baseQuestionInput), { numberOfItems: 4 })));
-            break;
-          case "matching":
-            ({ question } = await generateMatchingQuestion(__spreadProps(__spreadValues({}, baseQuestionInput), { numberOfPairs: 4 })));
-            break;
-          case "drag_and_drop":
-            generationError = `Question type "drag_and_drop" is planned but generation is not yet supported.`;
-            console.warn(`Skipping Drag and Drop question generation for topic: ${plannedQ.plannedTopic}. Not implemented.`);
-            break;
-          default:
-            generationError = `Question type "${plannedQ.plannedQuestionType}" is not supported for automated generation in this flow.`;
-        }
-        if (question) {
-          question.topic = plannedQ.plannedTopic;
-          question.bloomLevel = plannedQ.plannedBloomLevel;
-          question.difficulty = difficultyForAI;
-          question.contextCode = plannedQ.plannedContextId || (contextDescriptionForAI ? (selectedContextIds == null ? void 0 : selectedContextIds[0]) || "__custom__" : void 0);
-          if (question.points === void 0) question.points = 10;
-          generatedQuestions.push(question);
-        } else if (!generationError) {
-          generationError = `AI did not return a question object for ${plannedQ.plannedQuestionType}.`;
-        }
-      } catch (e) {
-        generationError = e.message || `Unknown error generating ${plannedQ.plannedQuestionType} question for topic ${plannedQ.plannedTopic}.`;
+      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 (generationError) {
-        console.error(`Error during Stage 2 generation for planned question index ${i}: ${generationError}`);
-        errors.push({
-          plannedQuestionIndex: i,
-          plannedTopic: plannedQ.plannedTopic,
-          plannedQuestionType: plannedQ.plannedQuestionType,
-          error: generationError
-        });
+      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 };
   }
-);
+  return { generatedQuestions, errors: errors.length > 0 ? errors : void 0 };
+}
 
 // src/utils/utils.ts
 var import_clsx = require("clsx");
@@ -2757,6 +3148,9 @@ function cn(...inputs) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  APIKeyService,
+  GEMINI_API_KEY_SERVICE_NAME,
+  QuizEditorService,
   QuizEngine,
   SCORMService,
   cn,