@thanh01.pmt/interactive-quiz-kit 1.0.64 → 1.0.65

package/dist/react-ui.cjs

@@ -99684,7 +99684,8 @@ var QuizContextSchema = zod.z.object({
   originalSubject: zod.z.string().optional(),
   originalCategory: zod.z.string().optional(),
   originalTopic: zod.z.string().optional(),
-  loDescription: zod.z.string().optional().describe("The full description of the learning objective for deep context.")
+  loDescription: zod.z.string().optional().describe("The full description of the learning objective for deep context."),
+  gradeBand: zod.z.string().optional()
 });
 var BaseQuestionGenerationClientInputSchema = zod.z.object({
   language: zod.z.string().optional().default("English"),
@@ -100129,1003 +100130,899 @@ async function generateMCQQuestion(clientInput, apiKey) {
   return { error: errorMessage };
 }
 
-// src/ai/flows/question-gen/generate-mrq-question.ts
+// src/react-ui/components/authoring/AIQuestionGeneratorModal.tsx
+var supportedQuestionTypesForAI = [
+  { value: "true_false", label: "True/False" },
+  { value: "multiple_choice", label: "Multiple Choice" },
+  { value: "multiple_response", label: "Multiple Response" },
+  { value: "short_answer", label: "Short Answer" },
+  { value: "numeric", label: "Numeric" },
+  { value: "fill_in_the_blanks", label: "Fill In The Blanks" },
+  { value: "sequence", label: "Sequence" },
+  { value: "matching", label: "Matching" }
+];
+var AIQuestionGeneratorModal = ({
+  isOpen,
+  onClose,
+  onQuestionGenerated,
+  language: language3,
+  questionType: questionTypeProp,
+  subjects = [],
+  topics = [],
+  gradeLevels = [],
+  bloomLevels = []
+}) => {
+  const [prompt, setPrompt] = React169.useState("");
+  const [isLoading, setIsLoading] = React169.useState(false);
+  const [error, setError] = React169.useState(null);
+  const { toast: toast2 } = useToast();
+  const [subjectCode, setSubjectCode] = React169.useState("");
+  const [topicCode, setTopicCode] = React169.useState("");
+  const [gradeBand, setGradeBand] = React169.useState("");
+  const [bloomLevelCode, setBloomLevelCode] = React169.useState("");
+  const [selectedQuestionType, setSelectedQuestionType] = React169.useState("multiple_choice");
+  const [isApiKeyManagerModalOpen, setIsApiKeyManagerModalOpen] = React169.useState(false);
+  const [geminiApiKeyExists, setGeminiApiKeyExists] = React169.useState(false);
+  const finalQuestionType = questionTypeProp || selectedQuestionType;
+  React169.useEffect(() => {
+    if (isOpen) {
+      setPrompt("");
+      setError(null);
+      setIsLoading(false);
+      setSubjectCode("");
+      setTopicCode("");
+      setGradeBand("");
+      setBloomLevelCode("");
+      setSelectedQuestionType(questionTypeProp || "multiple_choice");
+      setGeminiApiKeyExists(APIKeyService.hasAPIKey(GEMINI_API_KEY_SERVICE_NAME));
+    }
+  }, [isOpen, questionTypeProp]);
+  const filteredTopics = React169.useMemo(() => {
+    if (!subjectCode) return [];
+    return topics.filter((t4) => t4.subjectCode === subjectCode);
+  }, [subjectCode, topics]);
+  const handleApiKeyModalClose = () => {
+    setIsApiKeyManagerModalOpen(false);
+    setGeminiApiKeyExists(APIKeyService.hasAPIKey(GEMINI_API_KEY_SERVICE_NAME));
+  };
+  const handleSubmit = async () => {
+    if (!prompt.trim()) {
+      setError("Please provide a prompt for the question.");
+      return;
+    }
+    const geminiKey = APIKeyService.getAPIKey(GEMINI_API_KEY_SERVICE_NAME);
+    if (!geminiKey) {
+      setError("Gemini API Key is not set. Please configure it.");
+      setGeminiApiKeyExists(false);
+      return;
+    }
+    setGeminiApiKeyExists(true);
+    setError(null);
+    setIsLoading(true);
+    try {
+      const quizContext = {
+        plannedTopic: prompt,
+        originalSubject: subjectCode,
+        originalTopic: topicCode,
+        gradeBand,
+        plannedBloomLevel: bloomLevelCode
+      };
+      const baseClientInput = {
+        language: language3,
+        difficulty: "medium",
+        quizContext
+      };
+      let generatedResult = {};
+      switch (finalQuestionType) {
+        case "true_false":
+          generatedResult = await generateTrueFalseQuestion(baseClientInput, geminiKey);
+          break;
+        case "multiple_choice":
+          generatedResult = await generateMCQQuestion({ ...baseClientInput, numberOfOptions: 4 }, geminiKey);
+          break;
+        // Add other cases as needed
+        default:
+          throw new Error(`AI generation for '${finalQuestionType}' is not implemented in this flow.`);
+      }
+      if (generatedResult.error) {
+        throw new Error(generatedResult.error);
+      }
+      if (generatedResult.question) {
+        const completeQuestion = generatedResult.question;
+        completeQuestion.subject = subjectCode;
+        completeQuestion.topic = topicCode;
+        completeQuestion.gradeBand = gradeBand;
+        completeQuestion.bloomLevel = bloomLevelCode;
+        if (completeQuestion.points === void 0) completeQuestion.points = 10;
+        onQuestionGenerated(completeQuestion);
+        toast2({ title: "AI Question Generated", description: "Review and edit the generated question." });
+        onClose();
+      } else {
+        throw new Error("AI did not return a valid question object.");
+      }
+    } catch (e3) {
+      console.error("AI Question Generation Error:", e3);
+      let errorMessage = e3.message || "An unknown error occurred.";
+      if (typeof errorMessage === "string" && errorMessage.includes("API key not valid")) {
+        errorMessage = "The provided Google Gemini API Key is invalid. Please check it.";
+        setGeminiApiKeyExists(false);
+      }
+      setError(errorMessage);
+      toast2({ title: "AI Generation Failed", description: errorMessage, variant: "destructive" });
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const comboboxOptions = {
+    subjects: subjects.map((s4) => ({ value: s4.code, label: s4.name })),
+    topics: filteredTopics.map((t4) => ({ value: t4.code, label: t4.name })),
+    gradeLevels: gradeLevels.map((g) => ({ value: g.code, label: g.name })),
+    bloomLevels: bloomLevels.map((b2) => ({ value: b2.code, label: b2.name }))
+  };
+  return /* @__PURE__ */ React169__namespace.default.createElement(React169__namespace.default.Fragment, null, /* @__PURE__ */ React169__namespace.default.createElement(Dialog2, { open: isOpen, onOpenChange: (open) => {
+    if (!open) onClose();
+  } }, /* @__PURE__ */ React169__namespace.default.createElement(DialogContent2, { className: "sm:max-w-[600px]" }, /* @__PURE__ */ React169__namespace.default.createElement(DialogHeader, null, /* @__PURE__ */ React169__namespace.default.createElement(DialogTitle2, { className: "flex items-center font-headline text-2xl" }, /* @__PURE__ */ React169__namespace.default.createElement(WandSparkles, { className: "mr-2 h-6 w-6 text-primary" }), " AI Question Generator"), /* @__PURE__ */ React169__namespace.default.createElement(DialogDescription2, null, "Provide a prompt and metadata to generate a '", finalQuestionType, "' question.")), /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-4 py-4 max-h-[60vh] overflow-y-auto px-2" }, !geminiApiKeyExists && /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "p-3 mb-4 border border-amber-500 bg-amber-50 rounded-md text-amber-700" }), !questionTypeProp && /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-2" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, { htmlFor: "ai-q-type-select" }, "Question Type"), /* @__PURE__ */ React169__namespace.default.createElement(Select2, { value: selectedQuestionType, onValueChange: (v) => setSelectedQuestionType(v) }, /* @__PURE__ */ React169__namespace.default.createElement(SelectTrigger2, { id: "ai-q-type-select" }, /* @__PURE__ */ React169__namespace.default.createElement(SelectValue2, null)), /* @__PURE__ */ React169__namespace.default.createElement(SelectContent2, null, supportedQuestionTypesForAI.map((type) => /* @__PURE__ */ React169__namespace.default.createElement(SelectItem2, { key: type.value, value: type.value }, type.label))))), /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-2" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, { htmlFor: "ai-prompt" }, "Prompt / Topic"), /* @__PURE__ */ React169__namespace.default.createElement(
+    Textarea,
+    {
+      id: "ai-prompt",
+      value: prompt,
+      onChange: (e3) => setPrompt(e3.target.value),
+      placeholder: "e.g., The process of photosynthesis, The causes of World War II, Basic Algebra Equations",
+      className: "min-h-[100px]"
+    }
+  )), /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "grid grid-cols-2 gap-4" }, /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-2" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, null, "Subject"), /* @__PURE__ */ React169__namespace.default.createElement(EditableCombobox, { options: comboboxOptions.subjects, value: subjectCode, onChange: setSubjectCode, placeholder: "Select or type a Subject..." })), /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-2" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, null, "Topic"), /* @__PURE__ */ React169__namespace.default.createElement(EditableCombobox, { options: comboboxOptions.topics, value: topicCode, onChange: setTopicCode, placeholder: "Select or type a Topic...", disabled: !subjectCode })), /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-2" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, null, "Grade Level"), /* @__PURE__ */ React169__namespace.default.createElement(EditableCombobox, { options: comboboxOptions.gradeLevels, value: gradeBand, onChange: setGradeBand, placeholder: "Select or type a Grade..." })), /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-2" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, null, "Bloom's Level"), /* @__PURE__ */ React169__namespace.default.createElement(EditableCombobox, { options: comboboxOptions.bloomLevels, value: bloomLevelCode, onChange: setBloomLevelCode, placeholder: "Select a Bloom's Level..." }))), error && /* @__PURE__ */ React169__namespace.default.createElement("p", { className: "text-sm text-destructive flex items-center mt-2" }, /* @__PURE__ */ React169__namespace.default.createElement(TriangleAlert, { className: "mr-1 h-4 w-4" }), " ", error)), /* @__PURE__ */ React169__namespace.default.createElement(DialogFooter, null, /* @__PURE__ */ React169__namespace.default.createElement(DialogClose2, { asChild: true }, /* @__PURE__ */ React169__namespace.default.createElement(Button, { type: "button", variant: "outline" }, "Cancel")), /* @__PURE__ */ React169__namespace.default.createElement(Button, { type: "button", onClick: handleSubmit, disabled: isLoading || !prompt.trim() || !geminiApiKeyExists }, isLoading ? /* @__PURE__ */ React169__namespace.default.createElement(LoaderCircle, { className: "mr-2 h-4 w-4 animate-spin" }) : /* @__PURE__ */ React169__namespace.default.createElement(WandSparkles, { className: "mr-2 h-4 w-4" }), "Generate Question")))), /* @__PURE__ */ React169__namespace.default.createElement(APIKeyManagerModal, { isOpen: isApiKeyManagerModalOpen, onClose: handleApiKeyModalClose }));
+};
+
+// src/react-ui/components/authoring/AIFullQuizGeneratorModal.tsx
 init_react_shim();
 
-// src/ai/flows/question-gen/generate-mrq-question-types.ts
+// src/ai/flows/generate-quiz-plan.ts
 init_react_shim();
-BaseQuestionGenerationClientInputSchema.extend({
-  numberOfOptions: zod.z.number().int().min(2).max(8).optional().default(5),
-  minCorrectAnswers: zod.z.number().int().min(1).optional().default(2),
-  maxCorrectAnswers: zod.z.number().int().min(1).optional().default(3)
+
+// src/ai/flows/generate-quiz-plan-types.ts
+init_react_shim();
+var TopicWithMetadataSchema = zod.z.object({
+  topic: zod.z.string().min(1),
+  ratio: zod.z.number().min(0).max(100),
+  originalLoId: zod.z.string().optional(),
+  originalSubject: zod.z.string().optional(),
+  originalCategory: zod.z.string().optional(),
+  originalTopic: zod.z.string().optional(),
+  commonMisconceptions: zod.z.array(zod.z.string()).optional()
 });
-var AIMRQOutputFieldsSchema = zod.z.object({
-  prompt: zod.z.string(),
-  options: zod.z.array(zod.z.object({ tempId: zod.z.string(), text: zod.z.string() })).min(2).max(8),
-  correctTempOptionIds: zod.z.array(zod.z.string()).min(1),
-  explanation: zod.z.string().optional(),
-  points: zod.z.number().optional().default(10),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: zod.z.string().optional(),
-  verifiedCategory: zod.z.string().optional().describe("The category this question actually addresses.")
+var BloomLevelStringsEnum = zod.z.enum(["remembering", "understanding", "applying", "analyzing", "evaluating", "creating"]);
+var fullQuizSupportedQuestionTypesArray = [
+  "true_false",
+  "multiple_choice",
+  "multiple_response",
+  "short_answer",
+  "numeric",
+  "fill_in_the_blanks",
+  "sequence",
+  "matching",
+  "drag_and_drop",
+  "coding"
+];
+zod.z.object({
+  language: zod.z.string().optional().default("English"),
+  totalQuestions: zod.z.number().int().min(1).max(50),
+  numCodingQuestions: zod.z.number().optional().default(0),
+  topics: zod.z.array(TopicWithMetadataSchema).min(1),
+  bloomLevels: zod.z.array(zod.z.object({
+    level: BloomLevelStringsEnum,
+    ratio: zod.z.number().min(0).max(100)
+  })).min(1),
+  selectedContextIds: zod.z.array(zod.z.string()).optional(),
+  selectedQuestionTypes: zod.z.array(zod.z.enum(fullQuizSupportedQuestionTypesArray)).min(1),
+  imageContexts: zod.z.array(zod.z.custom()).optional().describe("Library of available image contexts for the AI to use.")
+});
+var PlannedQuestionSchema = zod.z.object({
+  plannedTopic: zod.z.string().min(1).describe("The specific, assessable topic for this question."),
+  plannedQuestionType: zod.z.enum(fullQuizSupportedQuestionTypesArray).describe("The specific question type chosen."),
+  plannedBloomLevel: BloomLevelStringsEnum.describe("The Bloom's level assigned."),
+  plannedContextId: zod.z.string().optional().describe("The specific context ID chosen for this question."),
+  imageId: zod.z.string().nullable().optional().describe("The ID of the image from the context library to be used for this question."),
+  targetMisconception: zod.z.string().optional().describe("A specific common misconception this question should target."),
+  difficultyReason: zod.z.string().optional().describe("Strategic explanation of difficulty choice and placement."),
+  topicSpecificity: zod.z.enum(["broad", "focused", "specific"]).optional().describe("How specific the topic coverage should be."),
+  originalLoId: zod.z.string().optional(),
+  originalSubject: zod.z.string().optional(),
+  originalCategory: zod.z.string().optional(),
+  originalTopic: zod.z.string().optional()
+});
+var GenerateQuizPlanOutputSchema = zod.z.object({
+  quizPlan: zod.z.array(PlannedQuestionSchema).describe("A detailed plan for each question in the quiz."),
+  diversityMetrics: zod.z.object({
+    questionTypeDistribution: zod.z.record(zod.z.number()).optional(),
+    bloomLevelDistribution: zod.z.record(zod.z.number()).optional(),
+    maxConsecutiveSameType: zod.z.number().optional()
+  }).optional().describe("Metrics showing the diversity achieved in the plan."),
+  planningStrategy: zod.z.object({
+    overallApproach: zod.z.string().optional(),
+    keyDecisions: zod.z.array(zod.z.string()).optional()
+  }).optional()
 });
 
-// src/ai/flows/question-gen/generate-mrq-question.ts
-var MAX_RETRY_ATTEMPTS3 = 3;
-var RETRY_DELAY_MS3 = 3e3;
-function buildEnhancedPrompt3(clientInput, attemptNumber) {
-  const { quizContext, language: language3, difficulty, numberOfOptions, minCorrectAnswers, maxCorrectAnswers, imageUrl } = clientInput;
-  const category = quizContext?.originalCategory || "the specified technical category";
-  const attemptInfo = attemptNumber > 1 ? `
-## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed due to validation errors. Pay close attention to the number of correct answers and the JSON schema.
+// src/ai/flows/generate-quiz-plan.ts
+var QuizPlanLogger = class {
+  constructor() {
+    this.logs = [];
+    this.startTime = Date.now();
+  }
+  log(phase, data, duration) {
+    this.logs.push({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      phase,
+      data,
+      duration
+    });
+    if (duration !== void 0) {
+      console.log(`[${phase}] Completed in ${duration}ms:`, data);
+    } else {
+      console.log(`[${phase}]:`, data);
+    }
+  }
+  getLogs() {
+    return this.logs;
+  }
+  getTotalDuration() {
+    return Date.now() - this.startTime;
+  }
+};
+function generateQuestionTypeSelectionGuidance() {
+  return `
+QUESTION TYPE SELECTION BEST PRACTICES:
 
-` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and options must be directly related to the content of this image.` : "";
-  const contextStrings = [
-    `**Required Category:** ${category} (This is the ONLY language to be used)`,
-    quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
-    imageContextInstruction,
-    quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    quizContext?.targetMisconception && `**Target Misconception:** Use this to create plausible incorrect answers (distractors). The misconception is: "${quizContext.targetMisconception}"`,
-    quizContext?.difficultyReason && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
-  ].filter(Boolean).map((s4) => `- ${s4}`).join("\n");
-  const exampleJson = JSON.stringify({
-    prompt: "Which of the following are considered programming paradigms?",
-    options: [
-      { "tempId": "A", "text": "Object-Oriented" },
-      { "tempId": "B", "text": "Assembly" },
-      { "tempId": "C", "text": "Functional" },
-      { "tempId": "D", "text": "Procedural" },
-      { "tempId": "E", "text": "Middleware" }
-    ],
-    correctTempOptionIds: ["A", "C", "D"],
-    explanation: "Object-Oriented, Functional, and Procedural are all major programming paradigms. Assembly is a low-level language, and Middleware is a type of software, not a paradigm.",
-    points: 10,
-    difficulty: "medium",
-    topic: "Programming Paradigms",
-    verifiedCategory: category
-  }, null, 2);
-  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in the programming language: ${category}.
-Your sole mission is to create a high-quality, technically accurate Multiple Response Question. You must adhere to the following rules at all times.
+**TRUE_FALSE (true_false)**
+- Best for: Binary concepts, fact verification, common misconceptions
+- Bloom levels: Primarily Remembering, Understanding
+- Use when: Testing definitive statements, clarifying misconceptions
+- Example: "Photosynthesis only occurs during daytime" (targets timing misconception)
 
-## Core Rules (Non-negotiable)
-1.  **Category Purity:** The question, options, and explanation MUST be exclusively about **${category}**.
-2.  **Context Adherence:** The question's content must directly align with all provided context.
-3.  **Format Integrity:** You MUST return ONLY a single, valid JSON object that strictly follows the provided schema. Do not include any extra text or comments.
+**MULTIPLE CHOICE (multiple_choice)**
+- Best for: Concept selection, process understanding, comparison
+- Bloom levels: All levels, especially Understanding and Applying
+- Use when: Testing conceptual understanding with clear alternatives
+- Example: "Which factor most affects enzyme activity?" (applying knowledge)
 
-## CRITICAL CONTEXT FOR THIS QUESTION
-${contextStrings}
+**MULTIPLE RESPONSE (multiple_response)**
+- Best for: Identifying multiple correct factors, comprehensive understanding
+- Bloom levels: Understanding, Analyzing, Evaluating
+- Use when: Multiple correct answers exist, testing thorough knowledge
+- Example: "Select all factors that influence plant growth" (analyzing components)
 
-## Task: Generate the Question
-Based on all the rules and context above, generate a single Multiple Response Question.
-
-### Input Parameters
-- **Topic for Question:** ${quizContext?.plannedTopic || "General"}
-- **Language for Text:** ${language3}
-- **Difficulty Level:** ${difficulty}
-- **Number of Options:** Generate exactly ${numberOfOptions} options.
-- **Number of Correct Answers:** The 'correctTempOptionIds' array MUST contain between ${minCorrectAnswers} and ${maxCorrectAnswers} valid IDs from the options you generate.
-
-### Required JSON Output Format
-Your response must be ONLY the JSON object, matching this exact structure and field names.
+**FILL IN THE BLANKS (fill_in_the_blanks)**
+- Best for: Key terminology, formulas, specific facts
+- Bloom levels: Remembering, Understanding
+- Use when: Testing precise recall of important terms/concepts
+- Example: "The process of _____ converts light energy to chemical energy"
 
-${exampleJson}
+**NUMERIC (numeric)**
+- Best for: Calculations, quantitative problems, formula application
+- Bloom levels: Applying, Analyzing
+- Use when: Mathematical computations are required
+- Example: "Calculate the molarity of a 2L solution containing 0.5 moles of NaCl"
 
-Now, generate the JSON for the requested question.`;
-}
-async function generateMRQQuestion(clientInput, apiKey) {
-  if (clientInput.minCorrectAnswers > clientInput.maxCorrectAnswers) {
-    return { error: `Invalid input: minCorrectAnswers (${clientInput.minCorrectAnswers}) cannot be greater than maxCorrectAnswers (${clientInput.maxCorrectAnswers}).` };
-  }
-  if (clientInput.maxCorrectAnswers >= clientInput.numberOfOptions) {
-    return { error: `Invalid input: maxCorrectAnswers (${clientInput.maxCorrectAnswers}) must be less than the total numberOfOptions (${clientInput.numberOfOptions}).` };
-  }
-  const ai = new genai.GoogleGenAI({ apiKey });
-  const model = "gemini-2.5-flash";
-  const config3 = {
-    temperature: 0.8,
-    responseMimeType: "application/json",
-    thinkingConfig: {
-      thinkingBudget: 4e3
-    }
-  };
-  const attemptResults = [];
-  let lastError = null;
-  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS3; attempt++) {
-    const startTime = Date.now();
-    const promptText = buildEnhancedPrompt3(clientInput, attempt);
-    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
-    try {
-      DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
-      const parts = [{ text: promptText }];
-      if (clientInput.imageUrl) {
-        const mimeType = clientInput.imageUrl.endsWith(".png") ? "image/png" : "image/jpeg";
-        const imagePart = await urlToGenerativePart(clientInput.imageUrl, mimeType);
-        parts.unshift(imagePart);
-      }
-      const contents = [{ role: "user", parts }];
-      const aiResult = await ai.models.generateContent({
-        model,
-        config: config3,
-        contents
-      });
-      const response = aiResult;
-      const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
-      const duration = Date.now() - startTime;
-      DebugLogger.logResponse(attempt, rawText);
-      if (!rawText) {
-        throw new Error("AI returned an empty response.");
-      }
-      const parsedJson = JSON.parse(rawText);
-      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AIMRQOutputFieldsSchema.parse(parsedJson);
-      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      if (aiGeneratedContent.options.length !== clientInput.numberOfOptions) {
-        throw new Error(`AI generated ${aiGeneratedContent.options.length} options, but ${clientInput.numberOfOptions} were required.`);
-      }
-      const correctCount = aiGeneratedContent.correctTempOptionIds.length;
-      if (correctCount < clientInput.minCorrectAnswers || correctCount > clientInput.maxCorrectAnswers) {
-        throw new Error(`AI provided ${correctCount} correct answers, which is outside the required range of ${clientInput.minCorrectAnswers}-${clientInput.maxCorrectAnswers}.`);
-      }
-      if (clientInput.quizContext?.originalCategory) {
-        const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
-        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
-        if (verifiedCategory && verifiedCategory !== requiredCategory) {
-          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
-        }
-      }
-      const finalOptions = [];
-      const tempIdToFinalIdMap = {};
-      const allTempIds = /* @__PURE__ */ new Set();
-      aiGeneratedContent.options.forEach((aiOption) => {
-        const finalId = generateUniqueId("opt_mr_");
-        finalOptions.push({ id: finalId, text: aiOption.text });
-        tempIdToFinalIdMap[aiOption.tempId] = finalId;
-        allTempIds.add(aiOption.tempId);
-      });
-      const finalCorrectAnswerIds = aiGeneratedContent.correctTempOptionIds.map((tempId) => {
-        if (!allTempIds.has(tempId)) {
-          throw new Error(`AI provided an invalid correctTempOptionId ('${tempId}') which does not exist in the generated options.`);
-        }
-        return tempIdToFinalIdMap[tempId];
-      });
-      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.quizContext?.originalTopic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.quizContext?.plannedContextId,
-        bloomLevel: clientInput.quizContext?.plannedBloomLevel,
-        learningObjective: clientInput.quizContext?.originalLoId,
-        subject: clientInput.quizContext?.originalSubject,
-        category: clientInput.quizContext?.originalCategory,
-        imageUrl: clientInput.imageUrl
-      };
-      const validatedQuestion = MultipleResponseQuestionZodSchema.parse(completeQuestion);
-      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
-      console.log(`
-\u2705 MRQ generation successful on attempt ${attempt} (${duration}ms)`);
-      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
-      return { question: validatedQuestion };
-    } catch (error) {
-      lastError = error;
-      const duration = Date.now() - startTime;
-      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
-      const willRetry = attempt < MAX_RETRY_ATTEMPTS3;
-      DebugLogger.logRetryInfo(attempt, error, willRetry);
-      if (willRetry) {
-        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS3}ms...`);
-        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS3));
-      }
-    }
-  }
-  DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate MRQ question after ${MAX_RETRY_ATTEMPTS3} attempts. Last error: ${lastError?.message}`;
-  console.error("\n\u274C Final Result: FAILED");
-  console.error(errorMessage);
-  return { error: errorMessage };
-}
+**MATCHING (matching)**
+- Best for: Connecting related concepts, terminology pairs
+- Bloom levels: Remembering, Understanding
+- Use when: Testing relationships between terms and definitions
+- Example: Match organelles with their functions
 
-// src/ai/flows/question-gen/generate-short-answer-question.ts
-init_react_shim();
+**SEQUENCE (sequence)**
+- Best for: Process steps, chronological order, procedural knowledge
+- Bloom levels: Understanding, Applying, Analyzing
+- Use when: Order or sequence is critical to understanding
+- Example: "Arrange the steps of mitosis in correct order"
 
-// src/ai/flows/question-gen/generate-short-answer-question-types.ts
-init_react_shim();
-BaseQuestionGenerationClientInputSchema.extend({
-  isCaseSensitive: zod.z.boolean().optional().default(false)
-});
-var AIShortAnswerOutputFieldsSchema = zod.z.object({
-  prompt: zod.z.string().describe("The question text that prompts the user for a short answer."),
-  acceptedAnswers: zod.z.array(zod.z.string().min(1)).min(1).describe("An array of one or more acceptable short answers. Include common variations if applicable."),
-  // isCaseSensitive không cần thiết ở đây, chúng ta sẽ quản lý nó ở phía client
-  explanation: zod.z.string().optional(),
-  points: zod.z.number().optional().default(10),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: zod.z.string().optional(),
-  verifiedCategory: zod.z.string().optional()
-  // Thêm để xác thực
-});
+**DRAG AND DROP (drag_and_drop)**
+- Best for: Categorization, classification, spatial relationships
+- Bloom levels: Understanding, Applying, Analyzing
+- Use when: Grouping or organizing information is key
+- Example: "Classify these compounds as acids, bases, or neutral"
 
-// src/ai/flows/question-gen/generate-short-answer-question.ts
-var MAX_RETRY_ATTEMPTS4 = 3;
-var RETRY_DELAY_MS4 = 3e3;
-function buildEnhancedPrompt4(clientInput, attemptNumber) {
-  const { quizContext, language: language3, difficulty, imageUrl } = clientInput;
-  const category = quizContext?.originalCategory || "the specified technical category";
-  const attemptInfo = attemptNumber > 1 ? `
-## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed. Ensure 'acceptedAnswers' is a non-empty array of strings and the JSON is valid.
+**SHORT ANSWER (short_answer)**
+- Best for: Explanations, definitions, problem-solving steps
+- Bloom levels: Understanding, Applying, Analyzing, Evaluating, Creating
+- Use when: Requiring explanatory responses, open-ended thinking
+- Example: "Explain why enzymes are specific to certain substrates"
 
-` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and its short answer must be directly related to the content of this image.` : "";
-  const contextStrings = [
-    `**Required Category:** ${category}`,
-    quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
-    imageContextInstruction,
-    quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    quizContext?.targetMisconception && `**Target Misconception:** The question should require an answer that corrects this specific misconception: "${quizContext.targetMisconception}"`
-  ].filter(Boolean).map((s4) => `- ${s4}`).join("\n");
-  const exampleJson = JSON.stringify({
-    prompt: "In Swift, what keyword is used to declare a constant?",
-    acceptedAnswers: ["let"],
-    explanation: "The 'let' keyword is used to declare constants, which are values that cannot be changed after they are set. 'var' is used for variables.",
-    points: 10,
-    difficulty: "easy",
-    topic: "Swift Constants",
-    verifiedCategory: category
-  }, null, 2);
-  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
-Your mission is to create a high-quality, technically accurate Short Answer Question.
+**CODING (coding)**
+- Best for: Programming problems, algorithm implementation
+- Bloom levels: Applying, Analyzing, Evaluating, Creating
+- Use when: Technical implementation or code analysis is required
+- Example: "Write a function to calculate factorial recursively"
+`;
+}
+function generateAdvancedBloomGuidance() {
+  return `
+ADVANCED BLOOM'S TAXONOMY & QUESTION TYPE OPTIMIZATION:
 
-## Core Rules (Non-negotiable)
-1.  **Category Purity:** The question MUST be exclusively about **${category}**.
-2.  **Objective Answer:** The question must have a short, factual, and objective answer. Avoid questions that are subjective or require long explanations.
-3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object.
+**REMEMBERING (Knowledge Recall)**
+- Primary types: true_false, fill_in_the_blanks, matching
+- Secondary types: multiple_choice (simple recall)
+- Focus: Facts, terms, basic concepts, definitions
+- Misconception addressing: Use true_false to clarify common confusions
 
-## CRITICAL CONTEXT FOR THIS QUESTION
-${contextStrings}
+**UNDERSTANDING (Comprehension)**
+- Primary types: multiple_choice, short_answer, matching
+- Secondary types: multiple_response, sequence
+- Focus: Explanations, interpretations, examples, classifications
+- Best for: "Explain why...", "What does this mean...", "Give an example..."
 
-## Task: Generate the Question
-Based on all the rules and context above, generate a single Short Answer Question.
+**APPLYING (Using Knowledge)**
+- Primary types: numeric, short_answer, sequence, coding
+- Secondary types: multiple_choice, drag_and_drop
+- Focus: Problem-solving, implementing procedures, using methods
+- Best for: Calculations, step-by-step processes, practical applications
 
-### Input Parameters
-- **Topic for Question:** ${quizContext?.plannedTopic || "General"}
-- **Language for Text:** ${language3}
-- **Difficulty Level:** ${difficulty}
+**ANALYZING (Breaking Down Information)**
+- Primary types: multiple_response, short_answer, sequence, coding
+- Secondary types: drag_and_drop, multiple_choice
+- Focus: Identifying components, relationships, cause-effect
+- Best for: "What are the factors...", "How do these relate...", "Break down..."
 
-### Required JSON Output Format
-Your response must be ONLY the JSON object, matching this exact structure:
+**EVALUATING (Making Judgments)**
+- Primary types: short_answer, multiple_response, coding
+- Secondary types: multiple_choice (with justification)
+- Focus: Critiquing, judging, comparing alternatives, decision-making
+- Best for: "Which is better and why...", "Evaluate the approach...", "Critique..."
 
-${exampleJson}
+**CREATING (Producing New Work)**
+- Primary types: short_answer, coding, sequence
+- Secondary types: drag_and_drop (design tasks)
+- Focus: Designing, planning, producing, constructing
+- Best for: "Design a solution...", "Create a plan...", "Develop a strategy..."
+`;
+}
+function generateDiversityRules() {
+  return `
+ENHANCED DIVERSITY & QUALITY ASSURANCE RULES:
 
-Now, generate the JSON for the requested question.`;
+**Question Type Distribution Strategy:**
+1. Never place more than 3 consecutive questions of the same type
+2. Distribute question types based on their cognitive complexity
+3. For quizzes with 10+ questions, use at least 4 different question types
+4. For quizzes with 20+ questions, use at least 6 different question types
+5. Balance quick-answer types (true_false, multiple_choice) with deeper types (short_answer, coding)
+
+**Intelligent Difficulty Progression:**
+1. Opening (20%): Start with confidence-building questions (Remembering/Understanding)
+2. Building (40%): Gradually increase complexity (Understanding/Applying)
+3. Peak (30%): Most challenging questions (Analyzing/Evaluating/Creating)
+4. Closing (10%): Moderate challenge to end positively
+
+**Misconception-Driven Planning:**
+- When common misconceptions are provided, prioritize question types that can effectively address them
+- Use true_false for binary misconceptions
+- Use multiple_choice for concept selection misconceptions
+- Use short_answer for complex misconceptions requiring explanation
+
+**Contextual Intelligence:**
+- Programming/Technical topics: Favor coding, numeric, short_answer
+- Process-oriented topics: Favor sequence, short_answer, drag_and_drop
+- Conceptual topics: Favor multiple_choice, multiple_response, true_false
+- Factual topics: Favor fill_in_the_blanks, matching, true_false
+`;
 }
-async function generateShortAnswerQuestion(clientInput, apiKey) {
-  const ai = new genai.GoogleGenAI({ apiKey });
-  const model = "gemini-2.5-flash";
-  const config3 = {
-    temperature: 0.5,
-    responseMimeType: "application/json",
-    thinkingConfig: {
-      thinkingBudget: 4e3
+async function generateQuizPlan(clientInput, apiKey, imageContexts = []) {
+  const logger = new QuizPlanLogger();
+  try {
+    logger.log("VALIDATION_START", {
+      totalQuestions: clientInput.totalQuestions,
+      availableTypes: clientInput.selectedQuestionTypes,
+      topicCount: clientInput.topics.length,
+      bloomLevelCount: clientInput.bloomLevels.length
+    });
+    const totalTopicRatio = clientInput.topics.reduce((sum, t4) => sum + t4.ratio, 0);
+    if (Math.abs(totalTopicRatio - 100) > 1) {
+      throw new Error(`Total topic ratio must be 100%. Current sum: ${totalTopicRatio.toFixed(1)}%`);
     }
-  };
-  const attemptResults = [];
-  let lastError = null;
-  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS4; attempt++) {
-    const startTime = Date.now();
-    const promptText = buildEnhancedPrompt4(clientInput, attempt);
-    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
-    try {
-      DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
-      const parts = [{ text: promptText }];
-      if (clientInput.imageUrl) {
-        const mimeType = clientInput.imageUrl.endsWith(".png") ? "image/png" : "image/jpeg";
-        const imagePart = await urlToGenerativePart(clientInput.imageUrl, mimeType);
-        parts.unshift(imagePart);
-      }
-      const contents = [{ role: "user", parts }];
-      const aiResult = await ai.models.generateContent({ model, config: config3, contents });
-      const response = aiResult;
-      const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
-      const duration = Date.now() - startTime;
-      DebugLogger.logResponse(attempt, rawText);
-      if (!rawText) throw new Error("AI returned an empty response.");
-      const parsedJson = JSON.parse(rawText);
-      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AIShortAnswerOutputFieldsSchema.parse(parsedJson);
-      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      if (clientInput.quizContext?.originalCategory) {
-        const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
-        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
-        if (verifiedCategory && verifiedCategory !== requiredCategory) {
-          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
-        }
-      }
-      const completeQuestion = {
-        id: generateUniqueId("saq_ai_"),
-        questionType: "short_answer",
-        prompt: aiGeneratedContent.prompt,
-        acceptedAnswers: aiGeneratedContent.acceptedAnswers,
-        isCaseSensitive: clientInput.isCaseSensitive,
-        explanation: aiGeneratedContent.explanation,
-        points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
-        difficulty: clientInput.difficulty,
-        contextCode: clientInput.quizContext?.plannedContextId,
-        bloomLevel: clientInput.quizContext?.plannedBloomLevel,
-        learningObjective: clientInput.quizContext?.originalLoId,
-        subject: clientInput.quizContext?.originalSubject,
-        category: clientInput.quizContext?.originalCategory,
-        imageUrl: clientInput.imageUrl
-      };
-      const validatedQuestion = ShortAnswerQuestionZodSchema.parse(completeQuestion);
-      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
-      console.log(`
-\u2705 Short Answer generation successful on attempt ${attempt} (${duration}ms)`);
-      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
-      return { question: validatedQuestion };
-    } catch (error) {
-      lastError = error;
-      const duration = Date.now() - startTime;
-      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
-      const willRetry = attempt < MAX_RETRY_ATTEMPTS4;
-      DebugLogger.logRetryInfo(attempt, error, willRetry);
-      if (willRetry) {
-        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS4}ms...`);
-        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS4));
+    const totalBloomRatio = clientInput.bloomLevels.reduce((sum, b2) => sum + b2.ratio, 0);
+    if (Math.abs(totalBloomRatio - 100) > 1) {
+      throw new Error(`Total Bloom level ratio must be 100%. Current sum: ${totalBloomRatio.toFixed(1)}%`);
+    }
+    logger.log("VALIDATION_SUCCESS", {
+      topicRatioSum: totalTopicRatio,
+      bloomRatioSum: totalBloomRatio
+    });
+    const aiStartTime = Date.now();
+    const ai = new genai.GoogleGenAI({
+      apiKey
+    });
+    const model = "gemini-2.5-pro";
+    const config3 = {
+      temperature: 0.8,
+      thinkingConfig: {
+        thinkingBudget: 4096
+      },
+      responseMimeType: "application/json"
+    };
+    logger.log("AI_INITIALIZATION", { model }, Date.now() - aiStartTime);
+    const { language: language3, totalQuestions, numCodingQuestions = 0 } = clientInput;
+    const promptStartTime = Date.now();
+    const topicsDistribution = clientInput.topics.map((t4) => {
+      let topicString = `- Topic Context: "${t4.topic}", LoId: "${t4.originalLoId || "nil"}", Subject: "${t4.originalSubject || "nil"}", Category: "${t4.originalCategory || "nil"}", Topic: "${t4.originalTopic || "nil"}", Ratio: ${t4.ratio}%`;
+      if (t4.commonMisconceptions && t4.commonMisconceptions.length > 0) {
+        topicString += `
+    - Common Misconceptions: [${t4.commonMisconceptions.join(", ")}]`;
       }
+      return topicString;
+    }).join("\n    ");
+    const bloomDistribution = clientInput.bloomLevels.map(
+      (b2) => `- Level: "${b2.level}", Ratio: ${b2.ratio}%`
+    ).join("\n    ");
+    let questionTypesForPrompt = [...clientInput.selectedQuestionTypes];
+    if (numCodingQuestions === 0) {
+      questionTypesForPrompt = questionTypesForPrompt.filter(
+        (type) => type !== "short_answer" && type !== "coding"
+      );
     }
-  }
-  DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate Short Answer question after ${MAX_RETRY_ATTEMPTS4} attempts. Last error: ${lastError?.message}`;
-  console.error("\n\u274C Final Result: FAILED");
-  console.error(errorMessage);
-  return { error: errorMessage };
-}
+    const allowedQuestionTypes = questionTypesForPrompt.map((t4) => `'${t4}'`).join(", ");
+    const codingRequirement = numCodingQuestions > 0 ? `
+**CRITICAL CODING REQUIREMENT**: Exactly ${numCodingQuestions} questions in the plan MUST be of type 'coding'. These should typically be at 'applying' or higher Bloom levels and focus on implementation, debugging, or algorithm design.` : "";
+    const imageContextSection = imageContexts && imageContexts.length > 0 ? `
+## AVAILABLE IMAGE CONTEXT LIBRARY
+You have access to a library of pre-described images. When planning a question, if its subject, category, and topic match an image in this library AND the image's description is relevant to the planned question's topic, you MUST include the corresponding \`imageId\` in your output. Otherwise, leave the \`imageId\` field null or omit it.
 
-// src/ai/flows/question-gen/generate-numeric-question.ts
-init_react_shim();
+\`\`\`json
+${JSON.stringify(imageContexts.map((img) => ({ imageId: img.id, subject: img.subject, category: img.category, topic: img.topic, description: img.detailedDescription })), null, 2)}
+\`\`\`
+` : "";
+    const enhancedPromptText = `You are an elite educational assessment architect with expertise in cognitive science and adaptive learning. Your mission is to create a strategically optimized quiz plan that maximizes learning effectiveness.
 
-// src/ai/flows/question-gen/generate-numeric-question-types.ts
-init_react_shim();
-BaseQuestionGenerationClientInputSchema.extend({
-  allowDecimals: zod.z.boolean().optional().default(true),
-  minRange: zod.z.number().optional(),
-  maxRange: zod.z.number().optional(),
-  // Thêm trường tolerance để client có thể tùy chỉnh
-  tolerance: zod.z.number().min(0).optional().default(0)
-});
-var AINumericOutputFieldsSchema = zod.z.object({
-  prompt: zod.z.string(),
-  answer: zod.z.number(),
-  // AI có thể đề xuất một tolerance, nhưng chúng ta sẽ ưu tiên của client
-  tolerance: zod.z.number().min(0).optional(),
-  explanation: zod.z.string().optional(),
-  points: zod.z.number().optional().default(10),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: zod.z.string().optional(),
-  verifiedCategory: zod.z.string().optional()
-  // Thêm để xác thực
-});
+${generateQuestionTypeSelectionGuidance()}
 
-// src/ai/flows/question-gen/generate-numeric-question.ts
-var MAX_RETRY_ATTEMPTS5 = 3;
-var RETRY_DELAY_MS5 = 3e3;
-function buildEnhancedPrompt5(clientInput, attemptNumber) {
-  const { quizContext, language: language3, difficulty, minRange, maxRange, allowDecimals, imageUrl } = clientInput;
-  const category = quizContext?.originalCategory || "the specified technical category";
-  const attemptInfo = attemptNumber > 1 ? `
-## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed. Ensure the 'answer' is a valid number and fits within the specified constraints.
+${generateAdvancedBloomGuidance()}
 
-` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and its numerical answer must be directly related to the content of this image.` : "";
-  const contextStrings = [
-    `**Required Category:** ${category}`,
-    quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
-    imageContextInstruction,
-    quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    quizContext?.targetMisconception && `**Target Misconception:** The question should clarify this numerical error: "${quizContext.targetMisconception}"`
-  ].filter(Boolean).map((s4) => `- ${s4}`).join("\n");
-  const constraintStrings = [
-    minRange !== void 0 && `The final 'answer' MUST be greater than or equal to ${minRange}.`,
-    maxRange !== void 0 && `The final 'answer' MUST be less than or equal to ${maxRange}.`,
-    !allowDecimals && `The final 'answer' MUST be an integer (whole number).`
-  ].filter(Boolean).join("\n");
-  const exampleJson = JSON.stringify({
-    prompt: "A Swift `Int` on a 64-bit platform can store a maximum value of 2^63 - 1. What is the maximum value for an `Int8`?",
-    answer: 127,
-    tolerance: 0,
-    explanation: "An Int8 uses 8 bits. One bit is for the sign, leaving 7 bits for the value. The range is from -128 to 127 (2^7 - 1).",
-    points: 10,
-    difficulty: "medium",
-    topic: "Swift Data Types",
-    verifiedCategory: category
-  }, null, 2);
-  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
-Your mission is to create a high-quality, technically accurate Numeric Question.
+${generateDiversityRules()}
 
-## Core Rules (Non-negotiable)
-1.  **Category Purity:** The question MUST be exclusively about **${category}**.
-2.  **Quantitative Answer:** The question MUST ask for a specific, objective numerical answer.
-3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object.
+## COMPREHENSIVE QUIZ REQUIREMENTS:
 
-## CRITICAL CONTEXT FOR THIS QUESTION
-${contextStrings}
+**Target Language**: ${language3}
+**Total Questions**: ${totalQuestions}${codingRequirement}
 
-## Task: Generate the Question
-Based on all the rules and context above, generate a single Numeric Question.
+**Topic Distribution & Learning Context** (follow precisely):
+    ${topicsDistribution}
 
-### Input Parameters & Constraints
-- **Topic for Question:** ${quizContext?.plannedTopic || "General"}
-- **Language for Text:** ${language3}
-- **Difficulty Level:** ${difficulty}
-${constraintStrings ? `
-### CRITICAL CONSTRAINTS ON THE ANSWER
-${constraintStrings}` : ""}
+**Cognitive Complexity Distribution** (follow precisely):
+    ${bloomDistribution}
 
-### Required JSON Output Format
-Your response must be ONLY the JSON object, matching this exact structure:
+**Available Question Arsenal**: ${allowedQuestionTypes}
 
-${exampleJson}
+**Image Resources**: ${imageContextSection} 
 
-Now, generate the JSON for the requested question.`;
-}
-async function generateNumericQuestion(clientInput, apiKey) {
-  if (clientInput.minRange !== void 0 && clientInput.maxRange !== void 0 && clientInput.minRange > clientInput.maxRange) {
-    return { error: `Invalid input: minRange (${clientInput.minRange}) cannot be greater than maxRange (${clientInput.maxRange}).` };
-  }
-  const ai = new genai.GoogleGenAI({ apiKey });
-  const model = "gemini-2.5-flash";
-  const config3 = {
-    temperature: 0.4,
-    // Giữ nhiệt độ thấp cho các câu trả lời chính xác
-    responseMimeType: "application/json",
-    thinkingConfig: {
-      thinkingBudget: 4e3
+## STRATEGIC PLANNING METHODOLOGY:
+
+1. **Misconception Analysis**: If common misconceptions are provided, design questions specifically to address and correct them
+2. **Question Type Intelligence**: Select question types based on the cognitive demands and content nature
+3. **Difficulty Orchestration**: Create a learning journey that builds confidence while challenging appropriately
+4. **Diversity Optimization**: Ensure variety prevents monotony and maintains engagement
+5. **Context Sensitivity**: Match question types to topic characteristics (technical, conceptual, procedural)
+6. **Image Context Integration**: Intelligently associate questions with relevant images from the provided library to enhance contextual understanding.
+
+## ENHANCED OUTPUT FORMAT:
+
+Return ONLY a JSON object with this EXACT structure:
+
+\`\`\`json
+{
+  "quizPlan": [
+   {
+      "plannedTopic": "Specific, assessable topic derived from provided context",
+      "plannedQuestionType": "question_type_from_allowed_list",
+      "plannedBloomLevel": "bloom_level_from_requirements",
+      "plannedContextId": "THEO_ABS",
+      "imageId": "imgctx_12345abcde", // or null
+      "targetMisconception": "Specific misconception this question addresses (or 'none' if not applicable)",
+      "difficultyReason": "Strategic explanation of difficulty choice and placement",
+      "topicSpecificity": "broad|focused|specific",
+      "originalLoId": "corresponding_LoId_from_input",
+      "originalSubject": "corresponding_Subject_from_input",
+      "originalCategory": "corresponding_Category_from_input",
+      "originalTopic": "corresponding_Topic_from_input"
     }
-  };
-  const attemptResults = [];
-  let lastError = null;
-  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS5; attempt++) {
-    const startTime = Date.now();
-    const promptText = buildEnhancedPrompt5(clientInput, attempt);
-    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
-    try {
-      DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
-      const parts = [{ text: promptText }];
-      if (clientInput.imageUrl) {
-        const mimeType = clientInput.imageUrl.endsWith(".png") ? "image/png" : "image/jpeg";
-        const imagePart = await urlToGenerativePart(clientInput.imageUrl, mimeType);
-        parts.unshift(imagePart);
-      }
-      const contents = [{ role: "user", parts }];
-      const aiResult = await ai.models.generateContent({ model, config: config3, contents });
-      const response = aiResult;
-      const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
-      const duration = Date.now() - startTime;
-      DebugLogger.logResponse(attempt, rawText);
-      if (!rawText) throw new Error("AI returned an empty response.");
-      const parsedJson = JSON.parse(rawText);
-      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AINumericOutputFieldsSchema.parse(parsedJson);
-      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      const answer = aiGeneratedContent.answer;
-      if (clientInput.minRange !== void 0 && answer < clientInput.minRange) {
-        throw new Error(`AI answer ${answer} is less than the required minRange of ${clientInput.minRange}.`);
-      }
-      if (clientInput.maxRange !== void 0 && answer > clientInput.maxRange) {
-        throw new Error(`AI answer ${answer} is greater than the required maxRange of ${clientInput.maxRange}.`);
-      }
-      if (!clientInput.allowDecimals && !Number.isInteger(answer)) {
-        throw new Error(`AI answer ${answer} is not an integer, but decimals are not allowed.`);
-      }
-      if (clientInput.quizContext?.originalCategory) {
-        const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
-        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
-        if (verifiedCategory && verifiedCategory !== requiredCategory) {
-          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
-        }
+  ],
+  "diversityMetrics": {
+    "questionTypeDistribution": {"type1": count1, "type2": count2},
+    "bloomLevelDistribution": {"level1": count1, "level2": count2},
+    "maxConsecutiveSameType": number,
+    "difficultyProgression": "description of how difficulty progresses",
+    "misconceptionCoverage": number_of_misconceptions_addressed
+  },
+  "planningStrategy": {
+    "overallApproach": "Brief description of the strategic approach taken",
+    "keyDecisions": ["Major decision 1", "Major decision 2", "Major decision 3"]
+  }
+}
+\`\`\`
+
+Execute this plan with pedagogical precision. The quiz should feel like a carefully crafted learning journey that challenges and educates simultaneously.`;
+    logger.log("PROMPT_PREPARATION", {
+      promptLength: enhancedPromptText.length,
+      topicCount: clientInput.topics.length,
+      misconceptionCount: clientInput.topics.reduce((sum, t4) => sum + (t4.commonMisconceptions?.length || 0), 0)
+    }, Date.now() - promptStartTime);
+    const generationStartTime = Date.now();
+    const contents = [
+      {
+        role: "user",
+        parts: [
+          {
+            text: enhancedPromptText
+          }
+        ]
       }
-      const completeQuestion = {
-        id: generateUniqueId("num_ai_"),
-        questionType: "numeric",
-        prompt: aiGeneratedContent.prompt,
-        answer: aiGeneratedContent.answer,
-        tolerance: clientInput.tolerance ?? aiGeneratedContent.tolerance ?? 0,
-        explanation: aiGeneratedContent.explanation,
-        points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
-        difficulty: clientInput.difficulty,
-        contextCode: clientInput.quizContext?.plannedContextId,
-        bloomLevel: clientInput.quizContext?.plannedBloomLevel,
-        learningObjective: clientInput.quizContext?.originalLoId,
-        subject: clientInput.quizContext?.originalSubject,
-        category: clientInput.quizContext?.originalCategory,
-        imageUrl: clientInput.imageUrl
-      };
-      const validatedQuestion = NumericQuestionZodSchema.parse(completeQuestion);
-      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
-      console.log(`
-\u2705 Numeric generation successful on attempt ${attempt} (${duration}ms)`);
-      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
-      return { question: validatedQuestion };
-    } catch (error) {
-      lastError = error;
-      const duration = Date.now() - startTime;
-      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
-      const willRetry = attempt < MAX_RETRY_ATTEMPTS5;
-      DebugLogger.logRetryInfo(attempt, error, willRetry);
-      if (willRetry) {
-        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS5}ms...`);
-        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS5));
+    ];
+    const aiResult = await ai.models.generateContent({
+      model,
+      config: config3,
+      contents
+    });
+    const response = aiResult;
+    const generationDuration = Date.now() - generationStartTime;
+    logger.log("AI_GENERATION", {
+      responseLength: response.candidates?.[0]?.content?.parts?.[0]?.text?.length || 0,
+      duration: generationDuration
+    }, generationDuration);
+    const processingStartTime = Date.now();
+    const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
+    let jsonText = rawText;
+    if (!rawText.trim().startsWith("{") && !rawText.trim().startsWith("[")) {
+      jsonText = extractJsonFromMarkdown(rawText);
+    }
+    logger.log("JSON_EXTRACTION", {
+      rawTextLength: rawText.length,
+      extractedJsonLength: jsonText.length
+    });
+    const aiGeneratedContent = GenerateQuizPlanOutputSchema.parse(JSON.parse(jsonText));
+    logger.log("SCHEMA_VALIDATION", { success: true }, Date.now() - processingStartTime);
+    const validationStartTime = Date.now();
+    if (aiGeneratedContent.quizPlan.length !== clientInput.totalQuestions) {
+      throw new Error(`AI planned for ${aiGeneratedContent.quizPlan.length} questions, but ${clientInput.totalQuestions} were requested.`);
+    }
+    const invalidTypes = [];
+    aiGeneratedContent.quizPlan.forEach((item, index3) => {
+      if (!clientInput.selectedQuestionTypes.includes(item.plannedQuestionType)) {
+        invalidTypes.push(`Question ${index3 + 1}: '${item.plannedQuestionType}'`);
       }
+    });
+    if (invalidTypes.length > 0) {
+      throw new Error(`Invalid question types found: ${invalidTypes.join(", ")}`);
     }
+    const codingQuestions = aiGeneratedContent.quizPlan.filter((q2) => q2.plannedQuestionType === "coding");
+    if (numCodingQuestions > 0 && codingQuestions.length !== numCodingQuestions) {
+      throw new Error(`Expected ${numCodingQuestions} coding questions, but got ${codingQuestions.length}`);
+    }
+    const diversityAnalysis = validateConsecutiveTypes(aiGeneratedContent.quizPlan);
+    logger.log("VALIDATION_COMPLETE", {
+      questionCount: aiGeneratedContent.quizPlan.length,
+      codingQuestionCount: codingQuestions.length,
+      maxConsecutiveType: diversityAnalysis.maxConsecutive,
+      questionTypeDistribution: aiGeneratedContent.diversityMetrics?.questionTypeDistribution || {}
+    }, Date.now() - validationStartTime);
+    const finalResult = {
+      ...aiGeneratedContent,
+      logs: logger.getLogs()
+    };
+    logger.log("GENERATION_COMPLETE", {
+      totalDuration: logger.getTotalDuration(),
+      success: true,
+      finalQuestionCount: finalResult.quizPlan.length
+    }, logger.getTotalDuration());
+    console.log("\n=== QUIZ PLAN GENERATION SUMMARY ===");
+    console.log(`\u2705 Successfully generated ${finalResult.quizPlan.length} questions`);
+    console.log(`\u23F1\uFE0F Total generation time: ${logger.getTotalDuration()}ms`);
+    console.log(`\u{1F3AF} Question types: ${Object.keys(finalResult.diversityMetrics?.questionTypeDistribution || {}).join(", ")}`);
+    console.log(`\u{1F9E0} Bloom levels: ${Object.keys(finalResult.diversityMetrics?.bloomLevelDistribution || {}).join(", ")}`);
+    if (numCodingQuestions > 0) {
+      console.log(`\u{1F4BB} Coding questions: ${codingQuestions.length}/${numCodingQuestions} required`);
+    }
+    console.log(JSON.stringify(finalResult));
+    console.log("=====================================\n");
+    return finalResult;
+  } catch (error) {
+    logger.log("ERROR", {
+      message: error.message,
+      stack: error.stack,
+      totalDuration: logger.getTotalDuration()
+    });
+    console.error("\u274C Quiz Plan Generation Failed:", error.message);
+    console.error("\u{1F4CB} Full logs available in returned object");
+    throw new Error(`Failed to generate Quiz Plan: ${error.message}`);
   }
-  DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate Numeric question after ${MAX_RETRY_ATTEMPTS5} attempts. Last error: ${lastError?.message}`;
-  console.error("\n\u274C Final Result: FAILED");
-  console.error(errorMessage);
-  return { error: errorMessage };
 }
-
-// src/ai/flows/question-gen/generate-fitb-question.ts
-init_react_shim();
-
-// src/ai/flows/question-gen/generate-fitb-question-types.ts
-init_react_shim();
-BaseQuestionGenerationClientInputSchema.extend({
-  numberOfBlanks: zod.z.number().int().min(1).max(5).optional().default(1),
-  isCaseSensitive: zod.z.boolean().optional().default(false)
-});
-var AIFillInTheBlanksOutputFieldsSchema = zod.z.object({
-  prompt: zod.z.string().describe("The instructional text for the user, e.g., 'Fill in the blanks to complete the sentence.'"),
-  // Yêu cầu AI trả về cấu trúc segments trực tiếp
-  segments: zod.z.array(zod.z.object({
-    type: zod.z.enum(["text", "blank"]),
-    content: zod.z.string().optional().describe("The text content for a 'text' segment."),
-    acceptedAnswers: zod.z.array(zod.z.string().min(1)).min(1).optional().describe("An array of correct answers for a 'blank' segment.")
-  })).min(1).describe("An array of text and blank segments representing the question."),
-  explanation: zod.z.string().optional(),
-  points: zod.z.number().optional().default(10),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: zod.z.string().optional(),
-  verifiedCategory: zod.z.string().optional()
-  // Thêm để xác thực
-});
-
-// src/ai/flows/question-gen/generate-fitb-question.ts
-var MAX_RETRY_ATTEMPTS6 = 3;
-var RETRY_DELAY_MS6 = 3e3;
-function buildEnhancedPrompt6(clientInput, attemptNumber) {
-  const { quizContext, language: language3, difficulty, numberOfBlanks, imageUrl } = clientInput;
-  const category = quizContext?.originalCategory || "the specified technical category";
-  const attemptInfo = attemptNumber > 1 ? `
-## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed. Pay strict attention to the JSON schema, especially the 'segments' array structure. Ensure 'blank' segments have 'acceptedAnswers' and 'text' segments have 'content'.
-
-` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and blanks must be directly related to the content of this image.` : "";
-  const contextStrings = [
-    `**Required Category:** ${category}`,
-    quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
-    imageContextInstruction,
-    quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    quizContext?.targetMisconception && `**Target Misconception:** Design the blank to test this specific point: "${quizContext.targetMisconception}"`
-  ].filter(Boolean).map((s4) => `- ${s4}`).join("\n");
-  const exampleJson = JSON.stringify({
-    prompt: "Complete the following Swift code snippet.",
-    segments: [
-      { "type": "text", "content": "To declare a new function in Swift, you use the `" },
-      { "type": "blank", "acceptedAnswers": ["func"] },
-      { "type": "text", "content": "` keyword." }
-    ],
-    explanation: "The 'func' keyword is used to declare a function in the Swift programming language.",
-    points: 10,
-    difficulty: "easy",
-    topic: "Swift Function Declaration",
-    verifiedCategory: category
-  }, null, 2);
-  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
-Your mission is to create a high-quality, technically accurate Fill-in-the-Blanks Question.
-
-## Core Rules (Non-negotiable)
-1.  **Category Purity:** The question MUST be exclusively about **${category}**.
-2.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object that strictly follows the provided schema.
-3.  **Logical Segments:** For 'blank' segments, you MUST provide 'acceptedAnswers'. For 'text' segments, you MUST provide 'content'. Do not mix them.
-
-## CRITICAL CONTEXT FOR THIS QUESTION
-${contextStrings}
-
-## Task: Generate the Question
-Based on all the rules and context above, generate a single Fill-in-the-Blanks Question.
-
-### Input Parameters
-- **Topic for Question:** ${quizContext?.plannedTopic || "General"}
-- **Language for Text:** ${language3}
-- **Difficulty Level:** ${difficulty}
-- **Number of Blanks:** Generate exactly ${numberOfBlanks} segment(s) with type 'blank'.
-
-### Required JSON Output Format
-Your response must be ONLY the JSON object, matching this exact structure:
-
-${exampleJson}
-
-Now, generate the JSON for the requested question.`;
-}
-async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
-  const ai = new genai.GoogleGenAI({ apiKey });
-  const model = "gemini-2.5-flash";
-  const config3 = {
-    temperature: 0.8,
-    responseMimeType: "application/json",
-    thinkingConfig: {
-      thinkingBudget: 4e3
-    }
-  };
-  const attemptResults = [];
-  let lastError = null;
-  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS6; attempt++) {
-    const startTime = Date.now();
-    const promptText = buildEnhancedPrompt6(clientInput, attempt);
-    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
-    try {
-      DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
-      const parts = [{ text: promptText }];
-      if (clientInput.imageUrl) {
-        const mimeType = clientInput.imageUrl.endsWith(".png") ? "image/png" : "image/jpeg";
-        const imagePart = await urlToGenerativePart(clientInput.imageUrl, mimeType);
-        parts.unshift(imagePart);
-      }
-      const contents = [{ role: "user", parts }];
-      const aiResult = await ai.models.generateContent({ model, config: config3, contents });
-      const response = aiResult;
-      const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
-      const duration = Date.now() - startTime;
-      DebugLogger.logResponse(attempt, rawText);
-      if (!rawText) throw new Error("AI returned an empty response.");
-      const parsedJson = JSON.parse(rawText);
-      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AIFillInTheBlanksOutputFieldsSchema.parse(parsedJson);
-      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      const blankCount = aiGeneratedContent.segments.filter((s4) => s4.type === "blank").length;
-      if (blankCount !== clientInput.numberOfBlanks) {
-        throw new Error(`AI generated ${blankCount} blanks, but ${clientInput.numberOfBlanks} were required.`);
-      }
-      aiGeneratedContent.segments.forEach((segment, index3) => {
-        if (segment.type === "blank" && (!segment.acceptedAnswers || segment.acceptedAnswers.length === 0)) {
-          throw new Error(`Segment ${index3} is a 'blank' but is missing 'acceptedAnswers'.`);
-        }
-        if (segment.type === "text" && typeof segment.content !== "string") {
-          throw new Error(`Segment ${index3} is 'text' but is missing 'content'.`);
-        }
-      });
-      if (clientInput.quizContext?.originalCategory) {
-        const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
-        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
-        if (verifiedCategory && verifiedCategory !== requiredCategory) {
-          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
-        }
-      }
-      const finalSegments = [];
-      const finalAnswers = [];
-      aiGeneratedContent.segments.forEach((segment) => {
-        if (segment.type === "text") {
-          finalSegments.push({ type: "text", content: segment.content });
-        } else if (segment.type === "blank" && segment.acceptedAnswers) {
-          const blankId = generateUniqueId("blank_");
-          finalSegments.push({ type: "blank", id: blankId });
-          finalAnswers.push({ blankId, acceptedValues: segment.acceptedAnswers });
-        }
-      });
-      const completeQuestion = {
-        id: generateUniqueId("fitb_ai_"),
-        questionType: "fill_in_the_blanks",
-        prompt: aiGeneratedContent.prompt,
-        segments: finalSegments,
-        answers: finalAnswers,
-        isCaseSensitive: clientInput.isCaseSensitive,
-        explanation: aiGeneratedContent.explanation,
-        points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
-        difficulty: clientInput.difficulty,
-        contextCode: clientInput.quizContext?.plannedContextId,
-        bloomLevel: clientInput.quizContext?.plannedBloomLevel,
-        learningObjective: clientInput.quizContext?.originalLoId,
-        subject: clientInput.quizContext?.originalSubject,
-        category: clientInput.quizContext?.originalCategory,
-        imageUrl: clientInput.imageUrl
-      };
-      const validatedQuestion = FillInTheBlanksQuestionZodSchema.parse(completeQuestion);
-      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
-      console.log(`
-\u2705 FITB generation successful on attempt ${attempt} (${duration}ms)`);
-      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
-      return { question: validatedQuestion };
-    } catch (error) {
-      lastError = error;
-      const duration = Date.now() - startTime;
-      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
-      const willRetry = attempt < MAX_RETRY_ATTEMPTS6;
-      DebugLogger.logRetryInfo(attempt, error, willRetry);
-      if (willRetry) {
-        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS6}ms...`);
-        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS6));
+function validateConsecutiveTypes(quizPlan) {
+  let maxConsecutive = 1;
+  let maxType = quizPlan[0]?.plannedQuestionType || "";
+  let maxStartIndex = 0;
+  let currentConsecutive = 1;
+  let currentType = quizPlan[0]?.plannedQuestionType || "";
+  let currentStartIndex = 0;
+  for (let i2 = 1; i2 < quizPlan.length; i2++) {
+    if (quizPlan[i2].plannedQuestionType === currentType) {
+      currentConsecutive++;
+    } else {
+      if (currentConsecutive > maxConsecutive) {
+        maxConsecutive = currentConsecutive;
+        maxType = currentType;
+        maxStartIndex = currentStartIndex;
       }
+      currentConsecutive = 1;
+      currentType = quizPlan[i2].plannedQuestionType;
+      currentStartIndex = i2;
     }
   }
-  DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate FITB question after ${MAX_RETRY_ATTEMPTS6} attempts. Last error: ${lastError?.message}`;
-  console.error("\n\u274C Final Result: FAILED");
-  console.error(errorMessage);
-  return { error: errorMessage };
-}
-
-// src/ai/flows/question-gen/generate-sequence-question.ts
-init_react_shim();
-
-// src/ai/flows/question-gen/generate-sequence-question-types.ts
-init_react_shim();
-BaseQuestionGenerationClientInputSchema.extend({
-  numberOfItems: zod.z.number().int().min(2).max(10).optional().default(4)
-});
-var AISequenceOutputFieldsSchema = zod.z.object({
-  prompt: zod.z.string().describe("The instructional text for the user, e.g., 'Arrange the steps in the correct order.'"),
-  // Yêu cầu AI cung cấp các item dưới dạng một mảng duy nhất đã được sắp xếp đúng thứ tự
-  // Điều này đơn giản hóa logic và giảm rủi ro
-  itemsInCorrectOrder: zod.z.array(zod.z.string().min(1)).min(2).describe("An array of strings, with each string representing an item to be sequenced. The array itself MUST be in the correct final order."),
-  explanation: zod.z.string().optional(),
-  points: zod.z.number().optional().default(10),
-  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
-  topic: zod.z.string().optional(),
-  verifiedCategory: zod.z.string().optional()
-  // Thêm để xác thực
-});
-
-// src/ai/flows/question-gen/generate-sequence-question.ts
-var MAX_RETRY_ATTEMPTS7 = 3;
-var RETRY_DELAY_MS7 = 3e3;
-function buildEnhancedPrompt7(clientInput, attemptNumber) {
-  const { quizContext, language: language3, difficulty, numberOfItems, imageUrl } = clientInput;
-  const category = quizContext?.originalCategory || "the specified technical category";
-  const attemptInfo = attemptNumber > 1 ? `
-## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed. Ensure the 'itemsInCorrectOrder' array has exactly the required number of items and the JSON is valid.
-
-` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The sequence of items must be directly related to the process or content shown in this image.` : "";
-  const contextStrings = [
-    `**Required Category:** ${category}`,
-    quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
-    imageContextInstruction,
-    quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    quizContext?.targetMisconception && `**Target Misconception:** The sequence should clarify this specific process error: "${quizContext.targetMisconception}"`
-  ].filter(Boolean).map((s4) => `- ${s4}`).join("\n");
-  const exampleJson = JSON.stringify({
-    prompt: "Arrange the steps to make a network request in Swift using URLSession.",
-    itemsInCorrectOrder: [
-      "Create a URL object.",
-      "Create a URLSessionDataTask with the URL.",
-      "Start the task by calling its resume() method.",
-      "Handle the completion handler with data, response, and error."
-    ],
-    explanation: "This is the fundamental sequence for a basic data task in URLSession.",
-    points: 10,
-    difficulty: "medium",
-    topic: "Swift Networking",
-    verifiedCategory: category
-  }, null, 2);
-  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
-Your mission is to create a high-quality, technically accurate Sequence Question.
-
-## Core Rules (Non-negotiable)
-1.  **Category Purity:** The question MUST be exclusively about **${category}**.
-2.  **Unambiguous Order:** The items MUST represent a clear, objective process, timeline, or order with only one correct sequence.
-3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object that strictly follows the provided schema.
-
-## CRITICAL CONTEXT FOR THIS QUESTION
-${contextStrings}
-
-## Task: Generate the Question
-Based on all the rules and context above, generate a single Sequence Question.
-
-### Input Parameters
-- **Topic for Question:** ${quizContext?.plannedTopic || "General"}
-- **Language for Text:** ${language3}
-- **Difficulty Level:** ${difficulty}
-- **Number of Items:** Generate an array 'itemsInCorrectOrder' containing exactly ${numberOfItems} items. The array itself MUST be in the correct final sequence.
-
-### Required JSON Output Format
-Your response must be ONLY the JSON object, matching this exact structure:
+  if (currentConsecutive > maxConsecutive) {
+    maxConsecutive = currentConsecutive;
+    maxType = currentType;
+    maxStartIndex = currentStartIndex;
+  }
+  return {
+    maxConsecutive,
+    type: maxType,
+    startIndex: maxStartIndex
+  };
+}
 
-${exampleJson}
+// src/ai/flows/generate-questions-from-quiz-plan.ts
+init_react_shim();
 
-Now, generate the JSON for the requested question.`;
-}
-async function generateSequenceQuestion(clientInput, apiKey) {
-  const ai = new genai.GoogleGenAI({ apiKey });
-  const model = "gemini-2.5-flash";
-  const config3 = {
-    temperature: 0.7,
-    responseMimeType: "application/json",
-    thinkingConfig: {
-      thinkingBudget: 4e3
+// src/services/TopicDataService.ts
+init_react_shim();
+var TopicDataService = class {
+  /**
+   * Saves an array of LearningObjective objects to Local Storage, overwriting existing data.
+   * @param data The array of learning objectives to save.
+   */
+  static saveData(data) {
+    try {
+      if (typeof window === "undefined") return;
+      const serializedData = JSON.stringify(data);
+      localStorage.setItem(this.STORAGE_KEY, serializedData);
+    } catch (error) {
+      console.error("Error saving learning objectives to Local Storage:", error);
     }
-  };
-  const attemptResults = [];
-  let lastError = null;
-  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS7; attempt++) {
-    const startTime = Date.now();
-    const promptText = buildEnhancedPrompt7(clientInput, attempt);
-    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+  }
+  /**
+   * Merges a new set of learning objectives with the existing data in Local Storage.
+   * If an LO ID from newData already exists, it will be updated. Otherwise, it will be added.
+   * @param newData The array of new or updated learning objectives.
+   */
+  static mergeData(newData) {
+    const existingData = this.getData();
+    const loMap = new Map(existingData.map((lo) => [lo.loId, lo]));
+    newData.forEach((newLo) => {
+      loMap.set(newLo.loId, newLo);
+    });
+    const mergedData = Array.from(loMap.values());
+    this.saveData(mergedData);
+  }
+  /**
+   * Retrieves the array of LearningObjective objects from Local Storage.
+   * @returns An array of learning objectives, or an empty array if none are found or an error occurs.
+   */
+  static getData() {
     try {
-      DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
-      const parts = [{ text: promptText }];
-      if (clientInput.imageUrl) {
-        const mimeType = clientInput.imageUrl.endsWith(".png") ? "image/png" : "image/jpeg";
-        const imagePart = await urlToGenerativePart(clientInput.imageUrl, mimeType);
-        parts.unshift(imagePart);
-      }
-      const contents = [{ role: "user", parts }];
-      const aiResult = await ai.models.generateContent({ model, config: config3, contents });
-      const response = aiResult;
-      const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
-      const duration = Date.now() - startTime;
-      DebugLogger.logResponse(attempt, rawText);
-      if (!rawText) throw new Error("AI returned an empty response.");
-      const parsedJson = JSON.parse(rawText);
-      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AISequenceOutputFieldsSchema.parse(parsedJson);
-      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      if (aiGeneratedContent.itemsInCorrectOrder.length !== clientInput.numberOfItems) {
-        throw new Error(`AI generated ${aiGeneratedContent.itemsInCorrectOrder.length} items, but ${clientInput.numberOfItems} were required.`);
+      if (typeof window === "undefined") return [];
+      const storedData = localStorage.getItem(this.STORAGE_KEY);
+      return storedData ? JSON.parse(storedData) : [];
+    } catch (error) {
+      console.error("Error retrieving learning objectives from Local Storage:", error);
+      this.clearData();
+      return [];
+    }
+  }
+  /**
+   * Removes all learning objective data from Local Storage.
+   */
+  static clearData() {
+    try {
+      if (typeof window === "undefined") return;
+      localStorage.removeItem(this.STORAGE_KEY);
+    } catch (error) {
+      console.error("Error clearing learning objectives from Local Storage:", error);
+    }
+  }
+  /**
+   * Parses TSV content into an array of LearningObjective objects.
+   * @param tsvContent The raw string content from a .tsv file.
+   * @returns An object containing the successfully parsed data and any errors encountered.
+   */
+  static parseTSV(tsvContent) {
+    const lines = tsvContent.split("\n").filter((line) => line.trim() !== "");
+    if (lines.length < 2) {
+      return { data: [], errors: ["File is empty or contains only a header."] };
+    }
+    const headerLine = lines.shift();
+    const headers = headerLine.split("	").map((h3) => h3.trim());
+    if (headers.length !== this.EXPECTED_HEADERS.length || !this.EXPECTED_HEADERS.every((h3, i2) => h3 === headers[i2])) {
+      const errorMsg = `Invalid TSV header. Expected: "${this.EXPECTED_HEADERS.join("	")}". Received: "${headers.join("	")}"`;
+      return { data: [], errors: [errorMsg] };
+    }
+    const data = [];
+    const errors2 = [];
+    lines.forEach((line, index3) => {
+      const values = line.split("	").map((v) => v.trim());
+      if (values.length !== this.EXPECTED_HEADERS.length) {
+        errors2.push(`Line ${index3 + 2}: Incorrect number of columns. Expected ${this.EXPECTED_HEADERS.length}, but got ${values.length}.`);
+        return;
       }
-      if (clientInput.quizContext?.originalCategory) {
-        const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
-        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
-        if (verifiedCategory && verifiedCategory !== requiredCategory) {
-          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
-        }
+      const [
+        loId,
+        loDescription,
+        subject,
+        category,
+        topic,
+        keywordsStr,
+        grade,
+        stemElementsStr,
+        bloomLevelsStr
+      ] = values;
+      if (!loId || !subject || !category || !topic) {
+        errors2.push(`Line ${index3 + 2}: Missing required fields (LO ID, Subject, Category, or Topic).`);
+        return;
       }
-      const finalItems = [];
-      const finalCorrectOrder = [];
-      aiGeneratedContent.itemsInCorrectOrder.forEach((content4) => {
-        const id3 = generateUniqueId("seqi_");
-        finalItems.push({ id: id3, content: content4 });
-        finalCorrectOrder.push(id3);
-      });
-      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.quizContext?.originalTopic,
-        difficulty: clientInput.difficulty,
-        contextCode: clientInput.quizContext?.plannedContextId,
-        bloomLevel: clientInput.quizContext?.plannedBloomLevel,
-        learningObjective: clientInput.quizContext?.originalLoId,
-        subject: clientInput.quizContext?.originalSubject,
-        category: clientInput.quizContext?.originalCategory,
-        imageUrl: clientInput.imageUrl
+      const learningObjective = {
+        loId,
+        loDescription,
+        subject,
+        category,
+        topic,
+        keywords: keywordsStr.split(",").map((k3) => k3.trim()).filter(Boolean),
+        grade,
+        stemElements: stemElementsStr.split(",").map((s4) => s4.trim()).filter(Boolean),
+        bloomLevelsGuideline: bloomLevelsStr.split(",").map((b2) => b2.trim()).filter(Boolean)
       };
-      const validatedQuestion = SequenceQuestionZodSchema.parse(completeQuestion);
-      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
-      console.log(`
-\u2705 Sequence generation successful on attempt ${attempt} (${duration}ms)`);
-      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
-      return { question: validatedQuestion };
-    } catch (error) {
-      lastError = error;
-      const duration = Date.now() - startTime;
-      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
-      const willRetry = attempt < MAX_RETRY_ATTEMPTS7;
-      DebugLogger.logRetryInfo(attempt, error, willRetry);
-      if (willRetry) {
-        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS7}ms...`);
-        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS7));
-      }
-    }
+      data.push(learningObjective);
+    });
+    return { data, errors: errors2 };
   }
-  DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate Sequence question after ${MAX_RETRY_ATTEMPTS7} attempts. Last error: ${lastError?.message}`;
-  console.error("\n\u274C Final Result: FAILED");
-  console.error(errorMessage);
-  return { error: errorMessage };
-}
+  /**
+   * Gets a unique list of all subjects from the stored data.
+   * @returns An array of subject strings.
+   */
+  static getSubjects() {
+    const data = this.getData();
+    const subjects = data.map((item) => item.subject);
+    return [...new Set(subjects)].sort();
+  }
+  /**
+   * Gets a unique list of categories for a given subject.
+   * @param subject The subject to filter by.
+   * @returns An array of category strings.
+   */
+  static getCategoriesBySubject(subject) {
+    const data = this.getData();
+    const categories = data.filter((item) => item.subject === subject).map((item) => item.category);
+    return [...new Set(categories)].sort();
+  }
+  /**
+   * Gets a unique list of topics for a given category.
+   * @param category The category to filter by.
+   * @returns An array of topic strings.
+   */
+  static getTopicsByCategory(category) {
+    const data = this.getData();
+    const topics = data.filter((item) => item.category === category).map((item) => item.topic);
+    return [...new Set(topics)].sort();
+  }
+  /**
+   * Retrieves all LearningObjective details for a given list of topics.
+   * @param topics An array of topic strings to search for.
+   * @returns An array of matching LearningObjective objects.
+   */
+  static getLearningObjectivesByTopics(topics) {
+    const data = this.getData();
+    const topicSet = new Set(topics);
+    return data.filter((item) => topicSet.has(item.topic));
+  }
+};
+TopicDataService.STORAGE_KEY = "interactive_quiz_kit_learning_objectives";
+TopicDataService.EXPECTED_HEADERS = [
+  "LO ID",
+  "LO Description",
+  "Subject",
+  "Category",
+  "Topic",
+  "Keywords",
+  "Grade",
+  "STEM Element(s)",
+  "Bloom\u2019s Level(s) Guideline"
+];
 
-// src/ai/flows/question-gen/generate-matching-question.ts
+// src/ai/flows/question-gen/generate-mrq-question.ts
 init_react_shim();
 
-// src/ai/flows/question-gen/generate-matching-question-types.ts
+// src/ai/flows/question-gen/generate-mrq-question-types.ts
 init_react_shim();
 BaseQuestionGenerationClientInputSchema.extend({
-  numberOfPairs: zod.z.number().int().min(2).max(8).optional().default(4),
-  shuffleOptions: zod.z.boolean().optional().default(true)
+  numberOfOptions: zod.z.number().int().min(2).max(8).optional().default(5),
+  minCorrectAnswers: zod.z.number().int().min(1).optional().default(2),
+  maxCorrectAnswers: zod.z.number().int().min(1).optional().default(3)
 });
-var AIMatchingOutputFieldsSchema = zod.z.object({
-  prompt: zod.z.string().describe("The instructional text for the user, e.g., 'Match the concept to its definition.'"),
-  correctPairs: zod.z.array(zod.z.object({
-    promptText: zod.z.string().min(1).describe("The text for the left-hand side item (the prompt)."),
-    optionText: zod.z.string().min(1).describe("The text for the right-hand side item (the matching option).")
-  })).min(2),
+var AIMRQOutputFieldsSchema = zod.z.object({
+  prompt: zod.z.string(),
+  options: zod.z.array(zod.z.object({ tempId: zod.z.string(), text: zod.z.string() })).min(2).max(8),
+  correctTempOptionIds: zod.z.array(zod.z.string()).min(1),
   explanation: zod.z.string().optional(),
   points: zod.z.number().optional().default(10),
   difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
   topic: zod.z.string().optional(),
-  verifiedCategory: zod.z.string().optional()
-  // Thêm để xác thực
+  verifiedCategory: zod.z.string().optional().describe("The category this question actually addresses.")
 });
 
-// src/ai/flows/question-gen/generate-matching-question.ts
-var MAX_RETRY_ATTEMPTS8 = 3;
-var RETRY_DELAY_MS8 = 3e3;
-function buildEnhancedPrompt8(clientInput, attemptNumber) {
-  const { quizContext, language: language3, difficulty, numberOfPairs, imageUrl } = clientInput;
+// src/ai/flows/question-gen/generate-mrq-question.ts
+var MAX_RETRY_ATTEMPTS3 = 3;
+var RETRY_DELAY_MS3 = 3e3;
+function buildEnhancedPrompt3(clientInput, attemptNumber) {
+  const { quizContext, language: language3, difficulty, numberOfOptions, minCorrectAnswers, maxCorrectAnswers, imageUrl } = clientInput;
   const category = quizContext?.originalCategory || "the specified technical category";
   const attemptInfo = attemptNumber > 1 ? `
 ## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed. Please ensure the 'correctPairs' array has exactly the required number of items and the JSON is valid.
+Previous attempts failed due to validation errors. Pay close attention to the number of correct answers and the JSON schema.
 
 ` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The matching pairs must be directly related to the content of this image.` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and options must be directly related to the content of this image.` : "";
   const contextStrings = [
-    `**Required Category:** ${category}`,
+    `**Required Category:** ${category} (This is the ONLY language to be used)`,
     quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
     imageContextInstruction,
     quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    quizContext?.targetMisconception && `**Target Misconception:** Design a pair that specifically tests this confusion: "${quizContext.targetMisconception}"`
+    quizContext?.targetMisconception && `**Target Misconception:** Use this to create plausible incorrect answers (distractors). The misconception is: "${quizContext.targetMisconception}"`,
+    quizContext?.difficultyReason && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
   ].filter(Boolean).map((s4) => `- ${s4}`).join("\n");
   const exampleJson = JSON.stringify({
-    prompt: "Match each Swift collection type to its primary characteristic.",
-    correctPairs: [
-      { "promptText": "Array", "optionText": "An ordered, random-access collection." },
-      { "promptText": "Set", "optionText": "An unordered collection of unique elements." },
-      { "promptText": "Dictionary", "optionText": "An unordered collection of key-value associations." }
+    prompt: "Which of the following are considered programming paradigms?",
+    options: [
+      { "tempId": "A", "text": "Object-Oriented" },
+      { "tempId": "B", "text": "Assembly" },
+      { "tempId": "C", "text": "Functional" },
+      { "tempId": "D", "text": "Procedural" },
+      { "tempId": "E", "text": "Middleware" }
     ],
-    explanation: "These are the fundamental characteristics of Swift's main collection types.",
+    correctTempOptionIds: ["A", "C", "D"],
+    explanation: "Object-Oriented, Functional, and Procedural are all major programming paradigms. Assembly is a low-level language, and Middleware is a type of software, not a paradigm.",
     points: 10,
-    difficulty: "easy",
-    topic: "Swift Collection Types",
+    difficulty: "medium",
+    topic: "Programming Paradigms",
     verifiedCategory: category
   }, null, 2);
-  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
-Your mission is to create a high-quality, technically accurate Matching Question.
+  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in the programming language: ${category}.
+Your sole mission is to create a high-quality, technically accurate Multiple Response Question. You must adhere to the following rules at all times.
 
 ## Core Rules (Non-negotiable)
-1.  **Category Purity:** The question MUST be exclusively about **${category}**.
-2.  **Logical Pairs:** The items to be matched must have a clear, one-to-one relationship.
-3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object that strictly follows the provided schema.
+1.  **Category Purity:** The question, options, and explanation MUST be exclusively about **${category}**.
+2.  **Context Adherence:** The question's content must directly align with all provided context.
+3.  **Format Integrity:** You MUST return ONLY a single, valid JSON object that strictly follows the provided schema. Do not include any extra text or comments.
 
 ## CRITICAL CONTEXT FOR THIS QUESTION
 ${contextStrings}
 
 ## Task: Generate the Question
-Based on all the rules and context above, generate a single Matching Question.
+Based on all the rules and context above, generate a single Multiple Response Question.
 
 ### Input Parameters
 - **Topic for Question:** ${quizContext?.plannedTopic || "General"}
 - **Language for Text:** ${language3}
 - **Difficulty Level:** ${difficulty}
-- **Number of Pairs:** Generate exactly ${numberOfPairs} correct pairs in the 'correctPairs' array.
+- **Number of Options:** Generate exactly ${numberOfOptions} options.
+- **Number of Correct Answers:** The 'correctTempOptionIds' array MUST contain between ${minCorrectAnswers} and ${maxCorrectAnswers} valid IDs from the options you generate.
 
 ### Required JSON Output Format
-Your response must be ONLY the JSON object, matching this exact structure:
+Your response must be ONLY the JSON object, matching this exact structure and field names.
 
 ${exampleJson}
 
 Now, generate the JSON for the requested question.`;
 }
-async function generateMatchingQuestion(clientInput, apiKey) {
+async function generateMRQQuestion(clientInput, apiKey) {
+  if (clientInput.minCorrectAnswers > clientInput.maxCorrectAnswers) {
+    return { error: `Invalid input: minCorrectAnswers (${clientInput.minCorrectAnswers}) cannot be greater than maxCorrectAnswers (${clientInput.maxCorrectAnswers}).` };
+  }
+  if (clientInput.maxCorrectAnswers >= clientInput.numberOfOptions) {
+    return { error: `Invalid input: maxCorrectAnswers (${clientInput.maxCorrectAnswers}) must be less than the total numberOfOptions (${clientInput.numberOfOptions}).` };
+  }
   const ai = new genai.GoogleGenAI({ apiKey });
   const model = "gemini-2.5-flash";
   const config3 = {
@@ -101137,9 +101034,9 @@ async function generateMatchingQuestion(clientInput, apiKey) {
   };
   const attemptResults = [];
   let lastError = null;
-  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS8; attempt++) {
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS3; attempt++) {
     const startTime = Date.now();
-    const promptText = buildEnhancedPrompt8(clientInput, attempt);
+    const promptText = buildEnhancedPrompt3(clientInput, attempt);
     const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
     try {
       DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
@@ -101150,18 +101047,28 @@ async function generateMatchingQuestion(clientInput, apiKey) {
         parts.unshift(imagePart);
       }
       const contents = [{ role: "user", parts }];
-      const aiResult = await ai.models.generateContent({ model, config: config3, contents });
+      const aiResult = await ai.models.generateContent({
+        model,
+        config: config3,
+        contents
+      });
       const response = aiResult;
       const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
       const duration = Date.now() - startTime;
       DebugLogger.logResponse(attempt, rawText);
-      if (!rawText) throw new Error("AI returned an empty response.");
+      if (!rawText) {
+        throw new Error("AI returned an empty response.");
+      }
       const parsedJson = JSON.parse(rawText);
       DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AIMatchingOutputFieldsSchema.parse(parsedJson);
+      const aiGeneratedContent = AIMRQOutputFieldsSchema.parse(parsedJson);
       DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      if (aiGeneratedContent.correctPairs.length !== clientInput.numberOfPairs) {
-        throw new Error(`AI generated ${aiGeneratedContent.correctPairs.length} pairs, but ${clientInput.numberOfPairs} were required.`);
+      if (aiGeneratedContent.options.length !== clientInput.numberOfOptions) {
+        throw new Error(`AI generated ${aiGeneratedContent.options.length} options, but ${clientInput.numberOfOptions} were required.`);
+      }
+      const correctCount = aiGeneratedContent.correctTempOptionIds.length;
+      if (correctCount < clientInput.minCorrectAnswers || correctCount > clientInput.maxCorrectAnswers) {
+        throw new Error(`AI provided ${correctCount} correct answers, which is outside the required range of ${clientInput.minCorrectAnswers}-${clientInput.maxCorrectAnswers}.`);
       }
       if (clientInput.quizContext?.originalCategory) {
         const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
@@ -101170,1015 +101077,954 @@ async function generateMatchingQuestion(clientInput, apiKey) {
           throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
         }
       }
-      const finalPrompts = [];
       const finalOptions = [];
-      const finalCorrectAnswerMap = [];
-      aiGeneratedContent.correctPairs.forEach((pair2) => {
-        const promptId = generateUniqueId("m_p_");
-        const optionId = generateUniqueId("m_o_");
-        finalPrompts.push({ id: promptId, content: pair2.promptText });
-        finalOptions.push({ id: optionId, content: pair2.optionText });
-        finalCorrectAnswerMap.push({ promptId, optionId });
+      const tempIdToFinalIdMap = {};
+      const allTempIds = /* @__PURE__ */ new Set();
+      aiGeneratedContent.options.forEach((aiOption) => {
+        const finalId = generateUniqueId("opt_mr_");
+        finalOptions.push({ id: finalId, text: aiOption.text });
+        tempIdToFinalIdMap[aiOption.tempId] = finalId;
+        allTempIds.add(aiOption.tempId);
+      });
+      const finalCorrectAnswerIds = aiGeneratedContent.correctTempOptionIds.map((tempId) => {
+        if (!allTempIds.has(tempId)) {
+          throw new Error(`AI provided an invalid correctTempOptionId ('${tempId}') which does not exist in the generated options.`);
+        }
+        return tempIdToFinalIdMap[tempId];
       });
       const completeQuestion = {
-        id: generateUniqueId("match_ai_"),
-        questionType: "matching",
+        id: generateUniqueId("mrq_ai_"),
+        questionType: "multiple_response",
         prompt: aiGeneratedContent.prompt,
-        prompts: finalPrompts,
         options: finalOptions,
-        correctAnswerMap: finalCorrectAnswerMap,
-        shuffleOptions: clientInput.shuffleOptions,
+        correctAnswerIds: finalCorrectAnswerIds,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
         topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
-        difficulty: clientInput.difficulty,
+        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
         contextCode: clientInput.quizContext?.plannedContextId,
         bloomLevel: clientInput.quizContext?.plannedBloomLevel,
-        learningObjective: clientInput.quizContext?.originalLoId,
-        subject: clientInput.quizContext?.originalSubject,
-        category: clientInput.quizContext?.originalCategory,
-        imageUrl: clientInput.imageUrl
-      };
-      const validatedQuestion = MatchingQuestionZodSchema.parse(completeQuestion);
-      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
-      console.log(`
-\u2705 Matching generation successful on attempt ${attempt} (${duration}ms)`);
-      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
-      return { question: validatedQuestion };
-    } catch (error) {
-      lastError = error;
-      const duration = Date.now() - startTime;
-      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
-      const willRetry = attempt < MAX_RETRY_ATTEMPTS8;
-      DebugLogger.logRetryInfo(attempt, error, willRetry);
-      if (willRetry) {
-        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS8}ms...`);
-        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS8));
-      }
-    }
-  }
-  DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate Matching question after ${MAX_RETRY_ATTEMPTS8} attempts. Last error: ${lastError?.message}`;
-  console.error("\n\u274C Final Result: FAILED");
-  console.error(errorMessage);
-  return { error: errorMessage };
-}
-
-// src/react-ui/components/authoring/AIQuestionGeneratorModal.tsx
-var supportedQuestionTypesForAI = [
-  { value: "true_false", label: "True/False" },
-  { value: "multiple_choice", label: "Multiple Choice" },
-  { value: "multiple_response", label: "Multiple Response" },
-  { value: "short_answer", label: "Short Answer" },
-  { value: "numeric", label: "Numeric" },
-  { value: "fill_in_the_blanks", label: "Fill In The Blanks" },
-  { value: "sequence", label: "Sequence" },
-  { value: "matching", label: "Matching" }
-];
-var contextOptions = [
-  { shortContextId: "A", contextId: "THEO_ABS", contextDescription: "L\xFD thuy\u1EBFt/Tr\u1EEBu t\u01B0\u1EE3ng", contextExample: '"Ph\xE1t bi\u1EC3u \u0111\u1ECBnh lu\u1EADt III Newton." ho\u1EB7c "Gi\u1EA3i th\xEDch kh\xE1i ni\u1EC7m \u0111\u1EA1o h\xE0m."', keywords: "l\xFD thuy\u1EBFt, tr\u1EEBu t\u01B0\u1EE3ng, \u0111\u1ECBnh ngh\u0129a, kh\xE1i ni\u1EC7m, nguy\xEAn l\xFD, c\xF4ng th\u1EE9c, \u0111\u1ECBnh lu\u1EADt" },
-  { shortContextId: "B", contextId: "SPEC_CASE", contextDescription: "V\xED d\u1EE5 C\u1EE5 th\u1EC3/Tr\u01B0\u1EDDng h\u1EE3p Ri\xEAng", contextExample: '"T\xEDnh l\u1EF1c t\xE1c d\u1EE5ng l\xEAn v\u1EADt n\u1EB7ng 2kg r\u01A1i t\u1EF1 do." ho\u1EB7c "Cho h\xE0m s\u1ED1 y = x^2, t\xECm \u0111\u1EA1o h\xE0m t\u1EA1i x = 3."', keywords: "v\xED d\u1EE5, c\u1EE5 th\u1EC3, tr\u01B0\u1EDDng h\u1EE3p ri\xEAng, \xE1p d\u1EE5ng, t\xEDnh to\xE1n, minh h\u1ECDa, s\u1ED1 li\u1EC7u c\u1EE5 th\u1EC3" },
-  { shortContextId: "C", contextId: "NAT_OBS", contextDescription: "Hi\u1EC7n t\u01B0\u1EE3ng T\u1EF1 nhi\xEAn/Quan s\xE1t", contextExample: '"Gi\u1EA3i th\xEDch t\u1EA1i sao c\u1EA7u v\u1ED3ng xu\u1EA5t hi\u1EC7n sau c\u01A1n m\u01B0a." ho\u1EB7c "M\xF4 t\u1EA3 qu\xE1 tr\xECnh quang h\u1EE3p \u1EDF l\xE1 c\xE2y."', keywords: "hi\u1EC7n t\u01B0\u1EE3ng, t\u1EF1 nhi\xEAn, quan s\xE1t, gi\u1EA3i th\xEDch, m\xF4 t\u1EA3, th\u1EBF gi\u1EDBi th\u1EF1c, sinh h\u1ECDc, v\u1EADt l\xFD" },
-  { shortContextId: "D", contextId: "TECH_ENG", contextDescription: "\u1EE8ng d\u1EE5ng C\xF4ng ngh\u1EC7/K\u1EF9 thu\u1EADt", contextExample: '"Nguy\xEAn l\xFD ho\u1EA1t \u0111\u1ED9ng c\u1EE7a \u0111\u1ED9ng c\u01A1 \u0111\u1ED1t trong l\xE0 g\xEC?" ho\u1EB7c "Pin m\u1EB7t tr\u1EDDi chuy\u1EC3n \u0111\u1ED5i n\u0103ng l\u01B0\u1EE3ng \xE1nh s\xE1ng th\xE0nh \u0111i\u1EC7n n\u0103ng nh\u01B0 th\u1EBF n\xE0o?"', keywords: "\u1EE9ng d\u1EE5ng, c\xF4ng ngh\u1EC7, k\u1EF9 thu\u1EADt, thi\u1EBFt b\u1ECB, m\xE1y m\xF3c, ho\u1EA1t \u0111\u1ED9ng, nguy\xEAn l\xFD, ch\u1EBF t\u1EA1o" },
-  { shortContextId: "E", contextId: "EXP_INV", contextDescription: "Th\xED nghi\u1EC7m/\u0110i\u1EC1u tra Khoa h\u1ECDc", contextExample: '"Thi\u1EBFt k\u1EBF th\xED nghi\u1EC7m ch\u1EE9ng minh \u0111\u1ECBnh lu\u1EADt b\u1EA3o to\xE0n n\u0103ng l\u01B0\u1EE3ng." ho\u1EB7c "Ph\xE2n t\xEDch k\u1EBFt qu\u1EA3 th\xED nghi\u1EC7m v\u1EC1 t\u1ED1c \u0111\u1ED9 ph\u1EA3n \u1EE9ng."', keywords: "th\xED nghi\u1EC7m, \u0111i\u1EC1u tra, khoa h\u1ECDc, thi\u1EBFt k\u1EBF, quy tr\xECnh, k\u1EBFt qu\u1EA3, ph\xE2n t\xEDch, d\u1EEF li\u1EC7u" },
-  { shortContextId: "F", contextId: "REAL_PROB", contextDescription: "V\u1EA5n \u0111\u1EC1 Th\u1EF1c t\u1EBF/X\xE3 h\u1ED9i/M\xF4i tr\u01B0\u1EDDng", contextExample: '"\u0110\u1EC1 xu\u1EA5t gi\u1EA3i ph\xE1p gi\u1EA3m thi\u1EC3u \xF4 nhi\u1EC5m kh\xF4ng kh\xED t\u1EA1i \u0111\xF4 th\u1ECB." ho\u1EB7c "Ph\xE2n t\xEDch \u1EA3nh h\u01B0\u1EDFng c\u1EE7a bi\u1EBFn \u0111\u1ED5i kh\xED h\u1EADu \u0111\u1EBFn n\xF4ng nghi\u1EC7p."', keywords: "v\u1EA5n \u0111\u1EC1, th\u1EF1c t\u1EBF, x\xE3 h\u1ED9i, m\xF4i tr\u01B0\u1EDDng, gi\u1EA3i ph\xE1p, ph\xE2n t\xEDch, \u1EA3nh h\u01B0\u1EDFng, b\u1EC1n v\u1EEFng" },
-  { shortContextId: "G", contextId: "DATA_MOD", contextDescription: "Di\u1EC5n gi\u1EA3i D\u1EEF li\u1EC7u/M\xF4 h\xECnh h\xF3a", contextExample: '"D\u1EF1a v\xE0o bi\u1EC3u \u0111\u1ED3, nh\u1EADn x\xE9t xu h\u01B0\u1EDBng nhi\u1EC7t \u0111\u1ED9 to\xE0n c\u1EA7u." ho\u1EB7c "X\xE2y d\u1EF1ng m\xF4 h\xECnh to\xE1n h\u1ECDc m\xF4 t\u1EA3 s\u1EF1 t\u0103ng tr\u01B0\u1EDFng d\xE2n s\u1ED1."', keywords: "d\u1EEF li\u1EC7u, bi\u1EC3u \u0111\u1ED3, b\u1EA3ng s\u1ED1 li\u1EC7u, m\xF4 h\xECnh, di\u1EC5n gi\u1EA3i, ph\xE2n t\xEDch, xu h\u01B0\u1EDBng, d\u1EF1 \u0111o\xE1n" },
-  { shortContextId: "H", contextId: "HIST_SCI", contextDescription: "L\u1ECBch s\u1EED/Ph\xE1t tri\u1EC3n Khoa h\u1ECDc", contextExample: '"Tr\xECnh b\xE0y b\u1ED1i c\u1EA3nh ra \u0111\u1EDDi thuy\u1EBFt t\u01B0\u01A1ng \u0111\u1ED1i c\u1EE7a Einstein." ho\u1EB7c "Ai l\xE0 ng\u01B0\u1EDDi \u0111\u1EA7u ti\xEAn ph\xE1t hi\u1EC7n ra c\u1EA5u tr\xFAc DNA?"', keywords: "l\u1ECBch s\u1EED, ph\xE1t tri\u1EC3n, khoa h\u1ECDc, nh\xE0 khoa h\u1ECDc, ph\xE1t minh, kh\xE1m ph\xE1, b\u1ED1i c\u1EA3nh" },
-  { shortContextId: "I", contextId: "INTERDISC", contextDescription: "Li\xEAn ng\xE0nh (Interdisciplinary)", contextExample: '"S\u1EED d\u1EE5ng ki\u1EBFn th\u1EE9c To\xE1n v\xE0 V\u1EADt l\xFD \u0111\u1EC3 t\xEDnh qu\u1EF9 \u0111\u1EA1o c\u1EE7a v\u1EADt n\xE9m xi\xEAn." ho\u1EB7c "Ph\xE2n t\xEDch c\u01A1 ch\u1EBF h\xF3a sinh c\u1EE7a qu\xE1 tr\xECnh ti\xEAu h\xF3a."', keywords: "li\xEAn ng\xE0nh, t\xEDch h\u1EE3p, To\xE1n-L\xFD, Sinh-H\xF3a, Khoa h\u1ECDc-C\xF4ng ngh\u1EC7, k\u1EBFt n\u1ED1i ki\u1EBFn th\u1EE9c" },
-  { shortContextId: "J", contextId: "HYPO_COMP", contextDescription: "Gi\u1EA3 \u0111\u1ECBnh/So s\xE1nh T\xECnh hu\u1ED1ng", contextExample: '"N\u1EBFu Tr\xE1i \u0110\u1EA5t kh\xF4ng c\xF3 t\u1EEB tr\u01B0\u1EDDng th\xEC \u0111i\u1EC1u g\xEC s\u1EBD x\u1EA3y ra?" ho\u1EB7c "So s\xE1nh \u01B0u nh\u01B0\u1EE3c \u0111i\u1EC3m c\u1EE7a n\u0103ng l\u01B0\u1EE3ng h\u1EA1t nh\xE2n v\xE0 n\u0103ng l\u01B0\u1EE3ng m\u1EB7t tr\u1EDDi."', keywords: "gi\u1EA3 \u0111\u1ECBnh, so s\xE1nh, t\xECnh hu\u1ED1ng, n\u1EBFu...th\xEC, \u01B0u \u0111i\u1EC3m, nh\u01B0\u1EE3c \u0111i\u1EC3m, ph\xE2n t\xEDch, \u0111\xE1nh gi\xE1" },
-  { shortContextId: "__custom__", contextId: "__custom__", contextDescription: "Other (Custom Input)", contextExample: "", keywords: "custom, other, specific" }
-];
-var bloomLevelOptions = [
-  { value: "remembering", label: "Nh\u1EDB - D\u1EC5 (Remembering)" },
-  { value: "understanding", label: "Hi\u1EC3u - Trung B\xECnh (Understanding)" },
-  { value: "applying", label: "V\u1EADn D\u1EE5ng - Kh\xF3 (Applying)" }
-];
-var calculateCombinedDifficulty = (contextId, bloomLevel, qType, customContextInput) => {
-  let contextScore = 1;
-  const selectedContext = contextOptions.find((c4) => c4.contextId === contextId);
-  if (selectedContext) {
-    if (["THEO_ABS", "HIST_SCI", "__none__"].includes(selectedContext.contextId) || selectedContext.contextId === "__custom__" && !customContextInput.trim()) {
-      contextScore = 1;
-    } else if (["SPEC_CASE", "NAT_OBS", "DATA_MOD", "INTERDISC", "HYPO_COMP"].includes(selectedContext.contextId) || selectedContext.contextId === "__custom__" && customContextInput.trim()) {
-      contextScore = 2;
-    } else if (["TECH_ENG", "EXP_INV", "REAL_PROB"].includes(selectedContext.contextId)) {
-      contextScore = 3;
-    }
-  } else if (contextId === "__custom__" && customContextInput.trim()) {
-    contextScore = 2;
-  }
-  let bloomScore = 1;
-  if (bloomLevel === "understanding") bloomScore = 2;
-  else if (bloomLevel === "applying") bloomScore = 3;
-  let questionTypeScore = 1;
-  switch (qType) {
-    case "true_false":
-    case "multiple_choice":
-    case "short_answer":
-      questionTypeScore = 1;
-      break;
-    case "matching":
-    case "fill_in_the_blanks":
-    case "numeric":
-      questionTypeScore = 2;
-      break;
-    case "sequence":
-    case "multiple_response":
-      questionTypeScore = 3;
-      break;
-    default:
-      questionTypeScore = 1;
-  }
-  const totalScore = bloomScore + contextScore + questionTypeScore;
-  if (totalScore <= 4) return "easy";
-  if (totalScore <= 6) return "medium";
-  return "hard";
-};
-var AIQuestionGeneratorModal = ({
-  isOpen,
-  onClose,
-  onQuestionGenerated,
-  language: language3
-  // <-- NHẬN PROP
-}) => {
-  const [topic, setTopic] = React169.useState("");
-  const [selectedContextId, setSelectedContextId] = React169.useState("__none__");
-  const [customContextInput, setCustomContextInput] = React169.useState("");
-  const [questionType, setQuestionType] = React169.useState("multiple_choice");
-  const [selectedBloomLevel, setSelectedBloomLevel] = React169.useState("remembering");
-  const [isLoading, setIsLoading] = React169.useState(false);
-  const [error, setError] = React169.useState(null);
-  const [computedDifficultyForDisplay, setComputedDifficultyForDisplay] = React169.useState(null);
-  const { toast: toast2 } = useToast();
-  const [numberOfOptions, setNumberOfOptions] = React169.useState(4);
-  const [minCorrectAnswers, setMinCorrectAnswers] = React169.useState(1);
-  const [maxCorrectAnswers, setMaxCorrectAnswers] = React169.useState(2);
-  const [isCaseSensitive, setIsCaseSensitive] = React169.useState(false);
-  const [numberOfBlanks, setNumberOfBlanks] = React169.useState(2);
-  const [numberOfSequenceItems, setNumberOfSequenceItems] = React169.useState(4);
-  const [numberOfMatchingPairs, setNumberOfMatchingPairs] = React169.useState(4);
-  const [isApiKeyManagerModalOpen, setIsApiKeyManagerModalOpen] = React169.useState(false);
-  const [geminiApiKeyExists, setGeminiApiKeyExists] = React169.useState(false);
-  React169.useEffect(() => {
-    if (isOpen) {
-      setTopic("");
-      setSelectedContextId("__none__");
-      setCustomContextInput("");
-      setQuestionType("multiple_choice");
-      setSelectedBloomLevel("remembering");
-      setError(null);
-      setIsLoading(false);
-      setNumberOfOptions(4);
-      setMinCorrectAnswers(1);
-      setMaxCorrectAnswers(2);
-      setIsCaseSensitive(false);
-      setNumberOfBlanks(2);
-      setNumberOfSequenceItems(4);
-      setNumberOfMatchingPairs(4);
-      setGeminiApiKeyExists(APIKeyService.hasAPIKey(GEMINI_API_KEY_SERVICE_NAME));
-    }
-  }, [isOpen]);
-  React169.useEffect(() => {
-    if (isOpen) {
-      const difficulty = calculateCombinedDifficulty(selectedContextId, selectedBloomLevel, questionType, customContextInput);
-      setComputedDifficultyForDisplay(difficulty);
-      setGeminiApiKeyExists(APIKeyService.hasAPIKey(GEMINI_API_KEY_SERVICE_NAME));
-    }
-  }, [selectedContextId, selectedBloomLevel, questionType, customContextInput, isOpen]);
-  const handleApiKeyModalClose = () => {
-    setIsApiKeyManagerModalOpen(false);
-    setGeminiApiKeyExists(APIKeyService.hasAPIKey(GEMINI_API_KEY_SERVICE_NAME));
-  };
-  const handleSubmit = async () => {
-    if (!topic.trim()) {
-      setError("Please provide a topic for the question.");
-      return;
-    }
-    const geminiKey = APIKeyService.getAPIKey(GEMINI_API_KEY_SERVICE_NAME);
-    if (!geminiKey) {
-      setError("Gemini API Key is not set. Please set it via the settings icon in the header or the button below.");
-      setGeminiApiKeyExists(false);
-      return;
-    }
-    setGeminiApiKeyExists(true);
-    setError(null);
-    setIsLoading(true);
-    let contextDescriptionForAI = void 0;
-    if (selectedContextId === "__custom__") {
-      contextDescriptionForAI = customContextInput.trim() || void 0;
-    } else if (selectedContextId && selectedContextId !== "__none__") {
-      const selectedContextObj = contextOptions.find((c4) => c4.contextId === selectedContextId);
-      contextDescriptionForAI = selectedContextObj?.contextDescription;
-    }
-    const finalDifficultyForAI = calculateCombinedDifficulty(selectedContextId, selectedBloomLevel, questionType, customContextInput);
-    try {
-      let generatedQuestionData = null;
-      const baseClientInput = {
-        topic,
-        language: language3,
-        // <-- SỬ DỤNG PROP
-        difficulty: finalDifficultyForAI,
-        contextDescription: contextDescriptionForAI,
-        selectedContextId: selectedContextId !== "__none__" && selectedContextId !== "__custom__" ? selectedContextId : selectedContextId === "__custom__" && customContextInput.trim() ? "__custom__" : void 0
+        learningObjective: clientInput.quizContext?.originalLoId,
+        subject: clientInput.quizContext?.originalSubject,
+        category: clientInput.quizContext?.originalCategory,
+        imageUrl: clientInput.imageUrl
       };
-      switch (questionType) {
-        case "true_false":
-          generatedQuestionData = await generateTrueFalseQuestion(baseClientInput, geminiKey);
-          break;
-        case "multiple_choice":
-          generatedQuestionData = await generateMCQQuestion({ ...baseClientInput, numberOfOptions }, geminiKey);
-          break;
-        case "multiple_response":
-          if (minCorrectAnswers > maxCorrectAnswers || maxCorrectAnswers > numberOfOptions) {
-            throw new Error("Invalid settings for Multiple Response correct answers count or number of options.");
-          }
-          generatedQuestionData = await generateMRQQuestion({ ...baseClientInput, numberOfOptions, minCorrectAnswers, maxCorrectAnswers }, geminiKey);
-          break;
-        case "short_answer":
-          generatedQuestionData = await generateShortAnswerQuestion({ ...baseClientInput, isCaseSensitive }, geminiKey);
-          break;
-        case "numeric":
-          generatedQuestionData = await generateNumericQuestion({ ...baseClientInput, allowDecimals: true, tolerance: 0 }, geminiKey);
-          break;
-        case "fill_in_the_blanks":
-          generatedQuestionData = await generateFillInTheBlanksQuestion({ ...baseClientInput, numberOfBlanks, isCaseSensitive }, geminiKey);
-          break;
-        case "sequence":
-          generatedQuestionData = await generateSequenceQuestion({ ...baseClientInput, numberOfItems: numberOfSequenceItems }, geminiKey);
-          break;
-        case "matching":
-          generatedQuestionData = await generateMatchingQuestion({ ...baseClientInput, numberOfPairs: numberOfMatchingPairs, shuffleOptions: true }, geminiKey);
-          break;
-        default:
-          const _exhaustiveCheck = questionType;
-          throw new Error(`AI generation for question type "${_exhaustiveCheck}" is not implemented yet.`);
-      }
-      if (generatedQuestionData && generatedQuestionData.question) {
-        const completeQuestion = generatedQuestionData.question;
-        completeQuestion.difficulty = finalDifficultyForAI;
-        completeQuestion.bloomLevel = selectedBloomLevel;
-        completeQuestion.topic = completeQuestion.topic || topic;
-        if (completeQuestion.points === void 0) completeQuestion.points = 10;
-        onQuestionGenerated(completeQuestion);
-        toast2({ title: "AI Question Generated", description: "Review and edit the generated question." });
-        onClose();
-      } else {
-        throw new Error("AI did not return a valid question object.");
-      }
-    } catch (e3) {
-      console.error("AI Question Generation Error:", e3);
-      let errorMessage = e3.message || "An unknown error occurred during AI question generation.";
-      if (typeof errorMessage === "string" && (errorMessage.includes("API key not valid") || errorMessage.startsWith("FAILED_PRECONDITION"))) {
-        errorMessage = "The provided Google Gemini API Key is invalid or not configured correctly. Please check your API key in the settings.";
-        setGeminiApiKeyExists(false);
-      }
-      setError(errorMessage);
-      toast2({ title: "AI Generation Failed", description: errorMessage, variant: "destructive" });
-    } finally {
-      setIsLoading(false);
-    }
-  };
-  const renderSpecificParams = () => {
-    switch (questionType) {
-      case "multiple_choice":
-      case "multiple_response":
-        return /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-2" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, { htmlFor: "ai-num-options" }, "Number of Options (2-6 for MCQ, 2-8 for MRQ)"), /* @__PURE__ */ React169__namespace.default.createElement(
-          Input,
-          {
-            id: "ai-num-options",
-            type: "number",
-            value: numberOfOptions,
-            onChange: (e3) => setNumberOfOptions(parseInt(e3.target.value, 10)),
-            min: 2,
-            max: questionType === "multiple_choice" ? 6 : 8
-          }
-        ), questionType === "multiple_response" && /* @__PURE__ */ React169__namespace.default.createElement(React169__namespace.default.Fragment, null, /* @__PURE__ */ React169__namespace.default.createElement(Label2, { htmlFor: "ai-min-correct" }, "Min Correct Answers (MRQ)"), /* @__PURE__ */ React169__namespace.default.createElement(Input, { id: "ai-min-correct", type: "number", value: minCorrectAnswers, onChange: (e3) => setMinCorrectAnswers(parseInt(e3.target.value, 10)), min: 1, max: numberOfOptions }), /* @__PURE__ */ React169__namespace.default.createElement(Label2, { htmlFor: "ai-max-correct" }, "Max Correct Answers (MRQ)"), /* @__PURE__ */ React169__namespace.default.createElement(Input, { id: "ai-max-correct", type: "number", value: maxCorrectAnswers, onChange: (e3) => setMaxCorrectAnswers(parseInt(e3.target.value, 10)), min: minCorrectAnswers, max: numberOfOptions })));
-      case "short_answer":
-      case "fill_in_the_blanks":
-        return /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "flex items-center space-x-2" }, /* @__PURE__ */ React169__namespace.default.createElement("input", { type: "checkbox", id: "ai-case-sensitive", checked: isCaseSensitive, onChange: (e3) => setIsCaseSensitive(e3.target.checked), className: "h-4 w-4 rounded border-gray-300 text-primary focus:ring-primary" }), /* @__PURE__ */ React169__namespace.default.createElement(Label2, { htmlFor: "ai-case-sensitive" }, "Case Sensitive Answers"), questionType === "fill_in_the_blanks" && /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-1 ml-4" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, { htmlFor: "ai-num-blanks" }, "Approx. Number of Blanks (1-5)"), /* @__PURE__ */ React169__namespace.default.createElement(Input, { id: "ai-num-blanks", type: "number", value: numberOfBlanks, onChange: (e3) => setNumberOfBlanks(parseInt(e3.target.value, 10)), min: 1, max: 5 })));
-      case "sequence":
-        return /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-2" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, { htmlFor: "ai-num-seq-items" }, "Number of Items to Sequence (2-10)"), /* @__PURE__ */ React169__namespace.default.createElement(Input, { id: "ai-num-seq-items", type: "number", value: numberOfSequenceItems, onChange: (e3) => setNumberOfSequenceItems(parseInt(e3.target.value, 10)), min: 2, max: 10 }));
-      case "matching":
-        return /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-2" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, { htmlFor: "ai-num-match-pairs" }, "Number of Pairs to Match (2-8)"), /* @__PURE__ */ React169__namespace.default.createElement(Input, { id: "ai-num-match-pairs", type: "number", value: numberOfMatchingPairs, onChange: (e3) => setNumberOfMatchingPairs(parseInt(e3.target.value, 10)), min: 2, max: 8 }));
-      default:
-        return null;
-    }
-  };
-  return /* @__PURE__ */ React169__namespace.default.createElement(React169__namespace.default.Fragment, null, /* @__PURE__ */ React169__namespace.default.createElement(Dialog2, { open: isOpen, onOpenChange: (open) => {
-    if (!open) onClose();
-  } }, /* @__PURE__ */ React169__namespace.default.createElement(DialogContent2, { className: "sm:max-w-[550px]" }, /* @__PURE__ */ React169__namespace.default.createElement(DialogHeader, null, /* @__PURE__ */ React169__namespace.default.createElement(DialogTitle2, { className: "flex items-center font-headline text-2xl" }, /* @__PURE__ */ React169__namespace.default.createElement(WandSparkles, { className: "mr-2 h-6 w-6 text-primary" }), " AI Question Generator"), /* @__PURE__ */ React169__namespace.default.createElement(DialogDescription2, null, "Provide inputs and let AI generate a question for you.")), /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-4 py-4 max-h-[60vh] overflow-y-auto pl-2 pr-2" }, !geminiApiKeyExists && /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "p-3 mb-4 border border-amber-500 bg-amber-50 rounded-md text-amber-700" }, /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "flex items-start" }, /* @__PURE__ */ React169__namespace.default.createElement(TriangleAlert, { className: "h-5 w-5 mr-2 mt-0.5 flex-shrink-0" }), /* @__PURE__ */ React169__namespace.default.createElement("div", null, /* @__PURE__ */ React169__namespace.default.createElement("p", { className: "font-semibold" }, "Gemini API Key Required"), /* @__PURE__ */ React169__namespace.default.createElement("p", { className: "text-xs" }, "To use AI question generation, please set your Google Gemini API Key."), /* @__PURE__ */ React169__namespace.default.createElement(
-    Button,
-    {
-      variant: "link",
-      className: "p-0 h-auto text-xs text-amber-700 hover:text-amber-800 mt-1",
-      onClick: () => {
-        onClose();
-        setIsApiKeyManagerModalOpen(true);
+      const validatedQuestion = MultipleResponseQuestionZodSchema.parse(completeQuestion);
+      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
+      console.log(`
+\u2705 MRQ generation successful on attempt ${attempt} (${duration}ms)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } catch (error) {
+      lastError = error;
+      const duration = Date.now() - startTime;
+      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS3;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS3}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS3));
       }
-    },
-    "Set API Key Now"
-  )))), /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-2" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, { htmlFor: "ai-topic" }, "Topic"), /* @__PURE__ */ React169__namespace.default.createElement(
-    Textarea,
-    {
-      id: "ai-topic",
-      value: topic,
-      onChange: (e3) => setTopic(e3.target.value),
-      placeholder: "e.g., Photosynthesis, World War II History, Basic Algebra Equations",
-      className: "min-h-[80px]"
-    }
-  )), /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-2" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, { htmlFor: "ai-context-select" }, "Context (Optional)"), /* @__PURE__ */ React169__namespace.default.createElement(
-    Select2,
-    {
-      value: selectedContextId,
-      onValueChange: (value) => setSelectedContextId(value)
-    },
-    /* @__PURE__ */ React169__namespace.default.createElement(SelectTrigger2, { id: "ai-context-select" }, /* @__PURE__ */ React169__namespace.default.createElement(SelectValue2, { placeholder: "Select a context or choose 'Other'..." })),
-    /* @__PURE__ */ React169__namespace.default.createElement(SelectContent2, null, /* @__PURE__ */ React169__namespace.default.createElement(SelectItem2, { value: "__none__" }, "None (General Topic)"), contextOptions.map((opt) => /* @__PURE__ */ React169__namespace.default.createElement(SelectItem2, { key: opt.contextId, value: opt.contextId }, opt.contextDescription, " ", opt.shortContextId !== "__custom__" ? `(${opt.shortContextId})` : "")))
-  )), selectedContextId === "__custom__" && /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-2" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, { htmlFor: "ai-custom-context" }, "Custom Context"), /* @__PURE__ */ React169__namespace.default.createElement(
-    Textarea,
-    {
-      id: "ai-custom-context",
-      value: customContextInput,
-      onChange: (e3) => setCustomContextInput(e3.target.value),
-      placeholder: "Enter your specific context here...",
-      className: "min-h-[60px]"
     }
-  )), /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "grid grid-cols-2 gap-4" }, /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-2" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, { htmlFor: "ai-question-type" }, "Question Type"), /* @__PURE__ */ React169__namespace.default.createElement(
-    Select2,
-    {
-      value: questionType,
-      onValueChange: (value) => setQuestionType(value)
-    },
-    /* @__PURE__ */ React169__namespace.default.createElement(SelectTrigger2, { id: "ai-question-type" }, /* @__PURE__ */ React169__namespace.default.createElement(SelectValue2, { placeholder: "Select question type" })),
-    /* @__PURE__ */ React169__namespace.default.createElement(SelectContent2, null, supportedQuestionTypesForAI.map((qType) => /* @__PURE__ */ React169__namespace.default.createElement(SelectItem2, { key: qType.value, value: qType.value }, qType.label)))
-  )), /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "space-y-2" }, /* @__PURE__ */ React169__namespace.default.createElement(Label2, { htmlFor: "ai-bloom-level" }, "Bloom Level"), /* @__PURE__ */ React169__namespace.default.createElement(
-    Select2,
-    {
-      value: selectedBloomLevel,
-      onValueChange: (value) => setSelectedBloomLevel(value)
-    },
-    /* @__PURE__ */ React169__namespace.default.createElement(SelectTrigger2, { id: "ai-bloom-level" }, /* @__PURE__ */ React169__namespace.default.createElement(SelectValue2, { placeholder: "Select Bloom Level" })),
-    /* @__PURE__ */ React169__namespace.default.createElement(SelectContent2, null, bloomLevelOptions.map((level) => /* @__PURE__ */ React169__namespace.default.createElement(SelectItem2, { key: level.value, value: level.value }, level.label)))
-  ))), renderSpecificParams(), computedDifficultyForDisplay && /* @__PURE__ */ React169__namespace.default.createElement("div", { className: "mt-3 p-3 border rounded-md bg-secondary/50" }, /* @__PURE__ */ React169__namespace.default.createElement("p", { className: "text-sm font-medium text-foreground" }, "Calculated AI Difficulty: ", /* @__PURE__ */ React169__namespace.default.createElement("span", { className: "font-bold text-primary capitalize" }, computedDifficultyForDisplay))), error && /* @__PURE__ */ React169__namespace.default.createElement("p", { className: "text-sm text-destructive flex items-center mt-2" }, /* @__PURE__ */ React169__namespace.default.createElement(TriangleAlert, { className: "mr-1 h-4 w-4" }), " ", error)), /* @__PURE__ */ React169__namespace.default.createElement(DialogFooter, null, /* @__PURE__ */ React169__namespace.default.createElement(DialogClose2, { asChild: true }, /* @__PURE__ */ React169__namespace.default.createElement(Button, { type: "button", variant: "outline" }, "Cancel")), /* @__PURE__ */ React169__namespace.default.createElement(Button, { type: "button", onClick: handleSubmit, disabled: isLoading || !topic.trim() || !geminiApiKeyExists }, isLoading ? /* @__PURE__ */ React169__namespace.default.createElement(LoaderCircle, { className: "mr-2 h-4 w-4 animate-spin" }) : /* @__PURE__ */ React169__namespace.default.createElement(WandSparkles, { className: "mr-2 h-4 w-4" }), "Generate Question")))), /* @__PURE__ */ React169__namespace.default.createElement(APIKeyManagerModal, { isOpen: isApiKeyManagerModalOpen, onClose: handleApiKeyModalClose }));
-};
-
-// src/react-ui/components/authoring/AIFullQuizGeneratorModal.tsx
-init_react_shim();
+  }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate MRQ question after ${MAX_RETRY_ATTEMPTS3} attempts. Last error: ${lastError?.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
+}
 
-// src/ai/flows/generate-quiz-plan.ts
+// src/ai/flows/question-gen/generate-short-answer-question.ts
 init_react_shim();
 
-// src/ai/flows/generate-quiz-plan-types.ts
+// src/ai/flows/question-gen/generate-short-answer-question-types.ts
 init_react_shim();
-var TopicWithMetadataSchema = zod.z.object({
-  topic: zod.z.string().min(1),
-  ratio: zod.z.number().min(0).max(100),
-  originalLoId: zod.z.string().optional(),
-  originalSubject: zod.z.string().optional(),
-  originalCategory: zod.z.string().optional(),
-  originalTopic: zod.z.string().optional(),
-  commonMisconceptions: zod.z.array(zod.z.string()).optional()
-});
-var BloomLevelStringsEnum = zod.z.enum(["remembering", "understanding", "applying", "analyzing", "evaluating", "creating"]);
-var fullQuizSupportedQuestionTypesArray = [
-  "true_false",
-  "multiple_choice",
-  "multiple_response",
-  "short_answer",
-  "numeric",
-  "fill_in_the_blanks",
-  "sequence",
-  "matching",
-  "drag_and_drop",
-  "coding"
-];
-zod.z.object({
-  language: zod.z.string().optional().default("English"),
-  totalQuestions: zod.z.number().int().min(1).max(50),
-  numCodingQuestions: zod.z.number().optional().default(0),
-  topics: zod.z.array(TopicWithMetadataSchema).min(1),
-  bloomLevels: zod.z.array(zod.z.object({
-    level: BloomLevelStringsEnum,
-    ratio: zod.z.number().min(0).max(100)
-  })).min(1),
-  selectedContextIds: zod.z.array(zod.z.string()).optional(),
-  selectedQuestionTypes: zod.z.array(zod.z.enum(fullQuizSupportedQuestionTypesArray)).min(1),
-  imageContexts: zod.z.array(zod.z.custom()).optional().describe("Library of available image contexts for the AI to use.")
-});
-var PlannedQuestionSchema = zod.z.object({
-  plannedTopic: zod.z.string().min(1).describe("The specific, assessable topic for this question."),
-  plannedQuestionType: zod.z.enum(fullQuizSupportedQuestionTypesArray).describe("The specific question type chosen."),
-  plannedBloomLevel: BloomLevelStringsEnum.describe("The Bloom's level assigned."),
-  plannedContextId: zod.z.string().optional().describe("The specific context ID chosen for this question."),
-  imageId: zod.z.string().nullable().optional().describe("The ID of the image from the context library to be used for this question."),
-  targetMisconception: zod.z.string().optional().describe("A specific common misconception this question should target."),
-  difficultyReason: zod.z.string().optional().describe("Strategic explanation of difficulty choice and placement."),
-  topicSpecificity: zod.z.enum(["broad", "focused", "specific"]).optional().describe("How specific the topic coverage should be."),
-  originalLoId: zod.z.string().optional(),
-  originalSubject: zod.z.string().optional(),
-  originalCategory: zod.z.string().optional(),
-  originalTopic: zod.z.string().optional()
+BaseQuestionGenerationClientInputSchema.extend({
+  isCaseSensitive: zod.z.boolean().optional().default(false)
 });
-var GenerateQuizPlanOutputSchema = zod.z.object({
-  quizPlan: zod.z.array(PlannedQuestionSchema).describe("A detailed plan for each question in the quiz."),
-  diversityMetrics: zod.z.object({
-    questionTypeDistribution: zod.z.record(zod.z.number()).optional(),
-    bloomLevelDistribution: zod.z.record(zod.z.number()).optional(),
-    maxConsecutiveSameType: zod.z.number().optional()
-  }).optional().describe("Metrics showing the diversity achieved in the plan."),
-  planningStrategy: zod.z.object({
-    overallApproach: zod.z.string().optional(),
-    keyDecisions: zod.z.array(zod.z.string()).optional()
-  }).optional()
+var AIShortAnswerOutputFieldsSchema = zod.z.object({
+  prompt: zod.z.string().describe("The question text that prompts the user for a short answer."),
+  acceptedAnswers: zod.z.array(zod.z.string().min(1)).min(1).describe("An array of one or more acceptable short answers. Include common variations if applicable."),
+  // isCaseSensitive không cần thiết ở đây, chúng ta sẽ quản lý nó ở phía client
+  explanation: zod.z.string().optional(),
+  points: zod.z.number().optional().default(10),
+  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: zod.z.string().optional(),
+  verifiedCategory: zod.z.string().optional()
+  // Thêm để xác thực
 });
 
-// src/ai/flows/generate-quiz-plan.ts
-var QuizPlanLogger = class {
-  constructor() {
-    this.logs = [];
-    this.startTime = Date.now();
-  }
-  log(phase, data, duration) {
-    this.logs.push({
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      phase,
-      data,
-      duration
-    });
-    if (duration !== void 0) {
-      console.log(`[${phase}] Completed in ${duration}ms:`, data);
-    } else {
-      console.log(`[${phase}]:`, data);
+// src/ai/flows/question-gen/generate-short-answer-question.ts
+var MAX_RETRY_ATTEMPTS4 = 3;
+var RETRY_DELAY_MS4 = 3e3;
+function buildEnhancedPrompt4(clientInput, attemptNumber) {
+  const { quizContext, language: language3, difficulty, imageUrl } = clientInput;
+  const category = quizContext?.originalCategory || "the specified technical category";
+  const attemptInfo = attemptNumber > 1 ? `
+## DEBUG INFO - This is attempt #${attemptNumber}
+Previous attempts failed. Ensure 'acceptedAnswers' is a non-empty array of strings and the JSON is valid.
+
+` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and its short answer must be directly related to the content of this image.` : "";
+  const contextStrings = [
+    `**Required Category:** ${category}`,
+    quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    quizContext?.targetMisconception && `**Target Misconception:** The question should require an answer that corrects this specific misconception: "${quizContext.targetMisconception}"`
+  ].filter(Boolean).map((s4) => `- ${s4}`).join("\n");
+  const exampleJson = JSON.stringify({
+    prompt: "In Swift, what keyword is used to declare a constant?",
+    acceptedAnswers: ["let"],
+    explanation: "The 'let' keyword is used to declare constants, which are values that cannot be changed after they are set. 'var' is used for variables.",
+    points: 10,
+    difficulty: "easy",
+    topic: "Swift Constants",
+    verifiedCategory: category
+  }, null, 2);
+  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
+Your mission is to create a high-quality, technically accurate Short Answer Question.
+
+## Core Rules (Non-negotiable)
+1.  **Category Purity:** The question MUST be exclusively about **${category}**.
+2.  **Objective Answer:** The question must have a short, factual, and objective answer. Avoid questions that are subjective or require long explanations.
+3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object.
+
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Short Answer Question.
+
+### Input Parameters
+- **Topic for Question:** ${quizContext?.plannedTopic || "General"}
+- **Language for Text:** ${language3}
+- **Difficulty Level:** ${difficulty}
+
+### Required JSON Output Format
+Your response must be ONLY the JSON object, matching this exact structure:
+
+${exampleJson}
+
+Now, generate the JSON for the requested question.`;
+}
+async function generateShortAnswerQuestion(clientInput, apiKey) {
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config3 = {
+    temperature: 0.5,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
+    }
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS4; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt4(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
+      const parts = [{ text: promptText }];
+      if (clientInput.imageUrl) {
+        const mimeType = clientInput.imageUrl.endsWith(".png") ? "image/png" : "image/jpeg";
+        const imagePart = await urlToGenerativePart(clientInput.imageUrl, mimeType);
+        parts.unshift(imagePart);
+      }
+      const contents = [{ role: "user", parts }];
+      const aiResult = await ai.models.generateContent({ model, config: config3, contents });
+      const response = aiResult;
+      const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
+      const duration = Date.now() - startTime;
+      DebugLogger.logResponse(attempt, rawText);
+      if (!rawText) throw new Error("AI returned an empty response.");
+      const parsedJson = JSON.parse(rawText);
+      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
+      const aiGeneratedContent = AIShortAnswerOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      if (clientInput.quizContext?.originalCategory) {
+        const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
+      const completeQuestion = {
+        id: generateUniqueId("saq_ai_"),
+        questionType: "short_answer",
+        prompt: aiGeneratedContent.prompt,
+        acceptedAnswers: aiGeneratedContent.acceptedAnswers,
+        isCaseSensitive: clientInput.isCaseSensitive,
+        explanation: aiGeneratedContent.explanation,
+        points: aiGeneratedContent.points,
+        topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
+        difficulty: clientInput.difficulty,
+        contextCode: clientInput.quizContext?.plannedContextId,
+        bloomLevel: clientInput.quizContext?.plannedBloomLevel,
+        learningObjective: clientInput.quizContext?.originalLoId,
+        subject: clientInput.quizContext?.originalSubject,
+        category: clientInput.quizContext?.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      const validatedQuestion = ShortAnswerQuestionZodSchema.parse(completeQuestion);
+      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
+      console.log(`
+\u2705 Short Answer generation successful on attempt ${attempt} (${duration}ms)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } catch (error) {
+      lastError = error;
+      const duration = Date.now() - startTime;
+      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS4;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS4}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS4));
+      }
     }
   }
-  getLogs() {
-    return this.logs;
-  }
-  getTotalDuration() {
-    return Date.now() - this.startTime;
-  }
-};
-function generateQuestionTypeSelectionGuidance() {
-  return `
-QUESTION TYPE SELECTION BEST PRACTICES:
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate Short Answer question after ${MAX_RETRY_ATTEMPTS4} attempts. Last error: ${lastError?.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
+}
 
-**TRUE_FALSE (true_false)**
-- Best for: Binary concepts, fact verification, common misconceptions
-- Bloom levels: Primarily Remembering, Understanding
-- Use when: Testing definitive statements, clarifying misconceptions
-- Example: "Photosynthesis only occurs during daytime" (targets timing misconception)
+// src/ai/flows/question-gen/generate-numeric-question.ts
+init_react_shim();
 
-**MULTIPLE CHOICE (multiple_choice)**
-- Best for: Concept selection, process understanding, comparison
-- Bloom levels: All levels, especially Understanding and Applying
-- Use when: Testing conceptual understanding with clear alternatives
-- Example: "Which factor most affects enzyme activity?" (applying knowledge)
+// src/ai/flows/question-gen/generate-numeric-question-types.ts
+init_react_shim();
+BaseQuestionGenerationClientInputSchema.extend({
+  allowDecimals: zod.z.boolean().optional().default(true),
+  minRange: zod.z.number().optional(),
+  maxRange: zod.z.number().optional(),
+  // Thêm trường tolerance để client có thể tùy chỉnh
+  tolerance: zod.z.number().min(0).optional().default(0)
+});
+var AINumericOutputFieldsSchema = zod.z.object({
+  prompt: zod.z.string(),
+  answer: zod.z.number(),
+  // AI có thể đề xuất một tolerance, nhưng chúng ta sẽ ưu tiên của client
+  tolerance: zod.z.number().min(0).optional(),
+  explanation: zod.z.string().optional(),
+  points: zod.z.number().optional().default(10),
+  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: zod.z.string().optional(),
+  verifiedCategory: zod.z.string().optional()
+  // Thêm để xác thực
+});
 
-**MULTIPLE RESPONSE (multiple_response)**
-- Best for: Identifying multiple correct factors, comprehensive understanding
-- Bloom levels: Understanding, Analyzing, Evaluating
-- Use when: Multiple correct answers exist, testing thorough knowledge
-- Example: "Select all factors that influence plant growth" (analyzing components)
+// src/ai/flows/question-gen/generate-numeric-question.ts
+var MAX_RETRY_ATTEMPTS5 = 3;
+var RETRY_DELAY_MS5 = 3e3;
+function buildEnhancedPrompt5(clientInput, attemptNumber) {
+  const { quizContext, language: language3, difficulty, minRange, maxRange, allowDecimals, imageUrl } = clientInput;
+  const category = quizContext?.originalCategory || "the specified technical category";
+  const attemptInfo = attemptNumber > 1 ? `
+## DEBUG INFO - This is attempt #${attemptNumber}
+Previous attempts failed. Ensure the 'answer' is a valid number and fits within the specified constraints.
 
-**FILL IN THE BLANKS (fill_in_the_blanks)**
-- Best for: Key terminology, formulas, specific facts
-- Bloom levels: Remembering, Understanding
-- Use when: Testing precise recall of important terms/concepts
-- Example: "The process of _____ converts light energy to chemical energy"
+` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and its numerical answer must be directly related to the content of this image.` : "";
+  const contextStrings = [
+    `**Required Category:** ${category}`,
+    quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    quizContext?.targetMisconception && `**Target Misconception:** The question should clarify this numerical error: "${quizContext.targetMisconception}"`
+  ].filter(Boolean).map((s4) => `- ${s4}`).join("\n");
+  const constraintStrings = [
+    minRange !== void 0 && `The final 'answer' MUST be greater than or equal to ${minRange}.`,
+    maxRange !== void 0 && `The final 'answer' MUST be less than or equal to ${maxRange}.`,
+    !allowDecimals && `The final 'answer' MUST be an integer (whole number).`
+  ].filter(Boolean).join("\n");
+  const exampleJson = JSON.stringify({
+    prompt: "A Swift `Int` on a 64-bit platform can store a maximum value of 2^63 - 1. What is the maximum value for an `Int8`?",
+    answer: 127,
+    tolerance: 0,
+    explanation: "An Int8 uses 8 bits. One bit is for the sign, leaving 7 bits for the value. The range is from -128 to 127 (2^7 - 1).",
+    points: 10,
+    difficulty: "medium",
+    topic: "Swift Data Types",
+    verifiedCategory: category
+  }, null, 2);
+  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
+Your mission is to create a high-quality, technically accurate Numeric Question.
 
-**NUMERIC (numeric)**
-- Best for: Calculations, quantitative problems, formula application
-- Bloom levels: Applying, Analyzing
-- Use when: Mathematical computations are required
-- Example: "Calculate the molarity of a 2L solution containing 0.5 moles of NaCl"
+## Core Rules (Non-negotiable)
+1.  **Category Purity:** The question MUST be exclusively about **${category}**.
+2.  **Quantitative Answer:** The question MUST ask for a specific, objective numerical answer.
+3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object.
 
-**MATCHING (matching)**
-- Best for: Connecting related concepts, terminology pairs
-- Bloom levels: Remembering, Understanding
-- Use when: Testing relationships between terms and definitions
-- Example: Match organelles with their functions
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
 
-**SEQUENCE (sequence)**
-- Best for: Process steps, chronological order, procedural knowledge
-- Bloom levels: Understanding, Applying, Analyzing
-- Use when: Order or sequence is critical to understanding
-- Example: "Arrange the steps of mitosis in correct order"
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Numeric Question.
 
-**DRAG AND DROP (drag_and_drop)**
-- Best for: Categorization, classification, spatial relationships
-- Bloom levels: Understanding, Applying, Analyzing
-- Use when: Grouping or organizing information is key
-- Example: "Classify these compounds as acids, bases, or neutral"
+### Input Parameters & Constraints
+- **Topic for Question:** ${quizContext?.plannedTopic || "General"}
+- **Language for Text:** ${language3}
+- **Difficulty Level:** ${difficulty}
+${constraintStrings ? `
+### CRITICAL CONSTRAINTS ON THE ANSWER
+${constraintStrings}` : ""}
 
-**SHORT ANSWER (short_answer)**
-- Best for: Explanations, definitions, problem-solving steps
-- Bloom levels: Understanding, Applying, Analyzing, Evaluating, Creating
-- Use when: Requiring explanatory responses, open-ended thinking
-- Example: "Explain why enzymes are specific to certain substrates"
+### Required JSON Output Format
+Your response must be ONLY the JSON object, matching this exact structure:
 
-**CODING (coding)**
-- Best for: Programming problems, algorithm implementation
-- Bloom levels: Applying, Analyzing, Evaluating, Creating
-- Use when: Technical implementation or code analysis is required
-- Example: "Write a function to calculate factorial recursively"
-`;
+${exampleJson}
+
+Now, generate the JSON for the requested question.`;
+}
+async function generateNumericQuestion(clientInput, apiKey) {
+  if (clientInput.minRange !== void 0 && clientInput.maxRange !== void 0 && clientInput.minRange > clientInput.maxRange) {
+    return { error: `Invalid input: minRange (${clientInput.minRange}) cannot be greater than maxRange (${clientInput.maxRange}).` };
+  }
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config3 = {
+    temperature: 0.4,
+    // Giữ nhiệt độ thấp cho các câu trả lời chính xác
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
+    }
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS5; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt5(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
+      const parts = [{ text: promptText }];
+      if (clientInput.imageUrl) {
+        const mimeType = clientInput.imageUrl.endsWith(".png") ? "image/png" : "image/jpeg";
+        const imagePart = await urlToGenerativePart(clientInput.imageUrl, mimeType);
+        parts.unshift(imagePart);
+      }
+      const contents = [{ role: "user", parts }];
+      const aiResult = await ai.models.generateContent({ model, config: config3, contents });
+      const response = aiResult;
+      const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
+      const duration = Date.now() - startTime;
+      DebugLogger.logResponse(attempt, rawText);
+      if (!rawText) throw new Error("AI returned an empty response.");
+      const parsedJson = JSON.parse(rawText);
+      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
+      const aiGeneratedContent = AINumericOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      const answer = aiGeneratedContent.answer;
+      if (clientInput.minRange !== void 0 && answer < clientInput.minRange) {
+        throw new Error(`AI answer ${answer} is less than the required minRange of ${clientInput.minRange}.`);
+      }
+      if (clientInput.maxRange !== void 0 && answer > clientInput.maxRange) {
+        throw new Error(`AI answer ${answer} is greater than the required maxRange of ${clientInput.maxRange}.`);
+      }
+      if (!clientInput.allowDecimals && !Number.isInteger(answer)) {
+        throw new Error(`AI answer ${answer} is not an integer, but decimals are not allowed.`);
+      }
+      if (clientInput.quizContext?.originalCategory) {
+        const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
+      const completeQuestion = {
+        id: generateUniqueId("num_ai_"),
+        questionType: "numeric",
+        prompt: aiGeneratedContent.prompt,
+        answer: aiGeneratedContent.answer,
+        tolerance: clientInput.tolerance ?? aiGeneratedContent.tolerance ?? 0,
+        explanation: aiGeneratedContent.explanation,
+        points: aiGeneratedContent.points,
+        topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
+        difficulty: clientInput.difficulty,
+        contextCode: clientInput.quizContext?.plannedContextId,
+        bloomLevel: clientInput.quizContext?.plannedBloomLevel,
+        learningObjective: clientInput.quizContext?.originalLoId,
+        subject: clientInput.quizContext?.originalSubject,
+        category: clientInput.quizContext?.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      const validatedQuestion = NumericQuestionZodSchema.parse(completeQuestion);
+      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
+      console.log(`
+\u2705 Numeric generation successful on attempt ${attempt} (${duration}ms)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } catch (error) {
+      lastError = error;
+      const duration = Date.now() - startTime;
+      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS5;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS5}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS5));
+      }
+    }
+  }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate Numeric question after ${MAX_RETRY_ATTEMPTS5} attempts. Last error: ${lastError?.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
 }
-function generateAdvancedBloomGuidance() {
-  return `
-ADVANCED BLOOM'S TAXONOMY & QUESTION TYPE OPTIMIZATION:
 
-**REMEMBERING (Knowledge Recall)**
-- Primary types: true_false, fill_in_the_blanks, matching
-- Secondary types: multiple_choice (simple recall)
-- Focus: Facts, terms, basic concepts, definitions
-- Misconception addressing: Use true_false to clarify common confusions
+// src/ai/flows/question-gen/generate-fitb-question.ts
+init_react_shim();
 
-**UNDERSTANDING (Comprehension)**
-- Primary types: multiple_choice, short_answer, matching
-- Secondary types: multiple_response, sequence
-- Focus: Explanations, interpretations, examples, classifications
-- Best for: "Explain why...", "What does this mean...", "Give an example..."
+// src/ai/flows/question-gen/generate-fitb-question-types.ts
+init_react_shim();
+BaseQuestionGenerationClientInputSchema.extend({
+  numberOfBlanks: zod.z.number().int().min(1).max(5).optional().default(1),
+  isCaseSensitive: zod.z.boolean().optional().default(false)
+});
+var AIFillInTheBlanksOutputFieldsSchema = zod.z.object({
+  prompt: zod.z.string().describe("The instructional text for the user, e.g., 'Fill in the blanks to complete the sentence.'"),
+  // Yêu cầu AI trả về cấu trúc segments trực tiếp
+  segments: zod.z.array(zod.z.object({
+    type: zod.z.enum(["text", "blank"]),
+    content: zod.z.string().optional().describe("The text content for a 'text' segment."),
+    acceptedAnswers: zod.z.array(zod.z.string().min(1)).min(1).optional().describe("An array of correct answers for a 'blank' segment.")
+  })).min(1).describe("An array of text and blank segments representing the question."),
+  explanation: zod.z.string().optional(),
+  points: zod.z.number().optional().default(10),
+  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: zod.z.string().optional(),
+  verifiedCategory: zod.z.string().optional()
+  // Thêm để xác thực
+});
 
-**APPLYING (Using Knowledge)**
-- Primary types: numeric, short_answer, sequence, coding
-- Secondary types: multiple_choice, drag_and_drop
-- Focus: Problem-solving, implementing procedures, using methods
-- Best for: Calculations, step-by-step processes, practical applications
+// src/ai/flows/question-gen/generate-fitb-question.ts
+var MAX_RETRY_ATTEMPTS6 = 3;
+var RETRY_DELAY_MS6 = 3e3;
+function buildEnhancedPrompt6(clientInput, attemptNumber) {
+  const { quizContext, language: language3, difficulty, numberOfBlanks, imageUrl } = clientInput;
+  const category = quizContext?.originalCategory || "the specified technical category";
+  const attemptInfo = attemptNumber > 1 ? `
+## DEBUG INFO - This is attempt #${attemptNumber}
+Previous attempts failed. Pay strict attention to the JSON schema, especially the 'segments' array structure. Ensure 'blank' segments have 'acceptedAnswers' and 'text' segments have 'content'.
 
-**ANALYZING (Breaking Down Information)**
-- Primary types: multiple_response, short_answer, sequence, coding
-- Secondary types: drag_and_drop, multiple_choice
-- Focus: Identifying components, relationships, cause-effect
-- Best for: "What are the factors...", "How do these relate...", "Break down..."
+` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and blanks must be directly related to the content of this image.` : "";
+  const contextStrings = [
+    `**Required Category:** ${category}`,
+    quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    quizContext?.targetMisconception && `**Target Misconception:** Design the blank to test this specific point: "${quizContext.targetMisconception}"`
+  ].filter(Boolean).map((s4) => `- ${s4}`).join("\n");
+  const exampleJson = JSON.stringify({
+    prompt: "Complete the following Swift code snippet.",
+    segments: [
+      { "type": "text", "content": "To declare a new function in Swift, you use the `" },
+      { "type": "blank", "acceptedAnswers": ["func"] },
+      { "type": "text", "content": "` keyword." }
+    ],
+    explanation: "The 'func' keyword is used to declare a function in the Swift programming language.",
+    points: 10,
+    difficulty: "easy",
+    topic: "Swift Function Declaration",
+    verifiedCategory: category
+  }, null, 2);
+  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
+Your mission is to create a high-quality, technically accurate Fill-in-the-Blanks Question.
 
-**EVALUATING (Making Judgments)**
-- Primary types: short_answer, multiple_response, coding
-- Secondary types: multiple_choice (with justification)
-- Focus: Critiquing, judging, comparing alternatives, decision-making
-- Best for: "Which is better and why...", "Evaluate the approach...", "Critique..."
+## Core Rules (Non-negotiable)
+1.  **Category Purity:** The question MUST be exclusively about **${category}**.
+2.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object that strictly follows the provided schema.
+3.  **Logical Segments:** For 'blank' segments, you MUST provide 'acceptedAnswers'. For 'text' segments, you MUST provide 'content'. Do not mix them.
 
-**CREATING (Producing New Work)**
-- Primary types: short_answer, coding, sequence
-- Secondary types: drag_and_drop (design tasks)
-- Focus: Designing, planning, producing, constructing
-- Best for: "Design a solution...", "Create a plan...", "Develop a strategy..."
-`;
-}
-function generateDiversityRules() {
-  return `
-ENHANCED DIVERSITY & QUALITY ASSURANCE RULES:
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
 
-**Question Type Distribution Strategy:**
-1. Never place more than 3 consecutive questions of the same type
-2. Distribute question types based on their cognitive complexity
-3. For quizzes with 10+ questions, use at least 4 different question types
-4. For quizzes with 20+ questions, use at least 6 different question types
-5. Balance quick-answer types (true_false, multiple_choice) with deeper types (short_answer, coding)
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Fill-in-the-Blanks Question.
 
-**Intelligent Difficulty Progression:**
-1. Opening (20%): Start with confidence-building questions (Remembering/Understanding)
-2. Building (40%): Gradually increase complexity (Understanding/Applying)
-3. Peak (30%): Most challenging questions (Analyzing/Evaluating/Creating)
-4. Closing (10%): Moderate challenge to end positively
+### Input Parameters
+- **Topic for Question:** ${quizContext?.plannedTopic || "General"}
+- **Language for Text:** ${language3}
+- **Difficulty Level:** ${difficulty}
+- **Number of Blanks:** Generate exactly ${numberOfBlanks} segment(s) with type 'blank'.
 
-**Misconception-Driven Planning:**
-- When common misconceptions are provided, prioritize question types that can effectively address them
-- Use true_false for binary misconceptions
-- Use multiple_choice for concept selection misconceptions
-- Use short_answer for complex misconceptions requiring explanation
+### Required JSON Output Format
+Your response must be ONLY the JSON object, matching this exact structure:
 
-**Contextual Intelligence:**
-- Programming/Technical topics: Favor coding, numeric, short_answer
-- Process-oriented topics: Favor sequence, short_answer, drag_and_drop
-- Conceptual topics: Favor multiple_choice, multiple_response, true_false
-- Factual topics: Favor fill_in_the_blanks, matching, true_false
-`;
+${exampleJson}
+
+Now, generate the JSON for the requested question.`;
 }
-async function generateQuizPlan(clientInput, apiKey, imageContexts = []) {
-  const logger = new QuizPlanLogger();
-  try {
-    logger.log("VALIDATION_START", {
-      totalQuestions: clientInput.totalQuestions,
-      availableTypes: clientInput.selectedQuestionTypes,
-      topicCount: clientInput.topics.length,
-      bloomLevelCount: clientInput.bloomLevels.length
-    });
-    const totalTopicRatio = clientInput.topics.reduce((sum, t4) => sum + t4.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, b2) => sum + b2.ratio, 0);
-    if (Math.abs(totalBloomRatio - 100) > 1) {
-      throw new Error(`Total Bloom level ratio must be 100%. Current sum: ${totalBloomRatio.toFixed(1)}%`);
+async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config3 = {
+    temperature: 0.8,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
     }
-    logger.log("VALIDATION_SUCCESS", {
-      topicRatioSum: totalTopicRatio,
-      bloomRatioSum: totalBloomRatio
-    });
-    const aiStartTime = Date.now();
-    const ai = new genai.GoogleGenAI({
-      apiKey
-    });
-    const model = "gemini-2.5-pro";
-    const config3 = {
-      temperature: 0.8,
-      thinkingConfig: {
-        thinkingBudget: 4096
-      },
-      responseMimeType: "application/json"
-    };
-    logger.log("AI_INITIALIZATION", { model }, Date.now() - aiStartTime);
-    const { language: language3, totalQuestions, numCodingQuestions = 0 } = clientInput;
-    const promptStartTime = Date.now();
-    const topicsDistribution = clientInput.topics.map((t4) => {
-      let topicString = `- Topic Context: "${t4.topic}", LoId: "${t4.originalLoId || "nil"}", Subject: "${t4.originalSubject || "nil"}", Category: "${t4.originalCategory || "nil"}", Topic: "${t4.originalTopic || "nil"}", Ratio: ${t4.ratio}%`;
-      if (t4.commonMisconceptions && t4.commonMisconceptions.length > 0) {
-        topicString += `
-    - Common Misconceptions: [${t4.commonMisconceptions.join(", ")}]`;
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS6; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt6(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
+      const parts = [{ text: promptText }];
+      if (clientInput.imageUrl) {
+        const mimeType = clientInput.imageUrl.endsWith(".png") ? "image/png" : "image/jpeg";
+        const imagePart = await urlToGenerativePart(clientInput.imageUrl, mimeType);
+        parts.unshift(imagePart);
+      }
+      const contents = [{ role: "user", parts }];
+      const aiResult = await ai.models.generateContent({ model, config: config3, contents });
+      const response = aiResult;
+      const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
+      const duration = Date.now() - startTime;
+      DebugLogger.logResponse(attempt, rawText);
+      if (!rawText) throw new Error("AI returned an empty response.");
+      const parsedJson = JSON.parse(rawText);
+      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
+      const aiGeneratedContent = AIFillInTheBlanksOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      const blankCount = aiGeneratedContent.segments.filter((s4) => s4.type === "blank").length;
+      if (blankCount !== clientInput.numberOfBlanks) {
+        throw new Error(`AI generated ${blankCount} blanks, but ${clientInput.numberOfBlanks} were required.`);
+      }
+      aiGeneratedContent.segments.forEach((segment, index3) => {
+        if (segment.type === "blank" && (!segment.acceptedAnswers || segment.acceptedAnswers.length === 0)) {
+          throw new Error(`Segment ${index3} is a 'blank' but is missing 'acceptedAnswers'.`);
+        }
+        if (segment.type === "text" && typeof segment.content !== "string") {
+          throw new Error(`Segment ${index3} is 'text' but is missing 'content'.`);
+        }
+      });
+      if (clientInput.quizContext?.originalCategory) {
+        const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
+      const finalSegments = [];
+      const finalAnswers = [];
+      aiGeneratedContent.segments.forEach((segment) => {
+        if (segment.type === "text") {
+          finalSegments.push({ type: "text", content: segment.content });
+        } else if (segment.type === "blank" && segment.acceptedAnswers) {
+          const blankId = generateUniqueId("blank_");
+          finalSegments.push({ type: "blank", id: blankId });
+          finalAnswers.push({ blankId, acceptedValues: segment.acceptedAnswers });
+        }
+      });
+      const completeQuestion = {
+        id: generateUniqueId("fitb_ai_"),
+        questionType: "fill_in_the_blanks",
+        prompt: aiGeneratedContent.prompt,
+        segments: finalSegments,
+        answers: finalAnswers,
+        isCaseSensitive: clientInput.isCaseSensitive,
+        explanation: aiGeneratedContent.explanation,
+        points: aiGeneratedContent.points,
+        topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
+        difficulty: clientInput.difficulty,
+        contextCode: clientInput.quizContext?.plannedContextId,
+        bloomLevel: clientInput.quizContext?.plannedBloomLevel,
+        learningObjective: clientInput.quizContext?.originalLoId,
+        subject: clientInput.quizContext?.originalSubject,
+        category: clientInput.quizContext?.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      const validatedQuestion = FillInTheBlanksQuestionZodSchema.parse(completeQuestion);
+      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
+      console.log(`
+\u2705 FITB generation successful on attempt ${attempt} (${duration}ms)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } catch (error) {
+      lastError = error;
+      const duration = Date.now() - startTime;
+      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS6;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS6}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS6));
       }
-      return topicString;
-    }).join("\n    ");
-    const bloomDistribution = clientInput.bloomLevels.map(
-      (b2) => `- Level: "${b2.level}", Ratio: ${b2.ratio}%`
-    ).join("\n    ");
-    let questionTypesForPrompt = [...clientInput.selectedQuestionTypes];
-    if (numCodingQuestions === 0) {
-      questionTypesForPrompt = questionTypesForPrompt.filter(
-        (type) => type !== "short_answer" && type !== "coding"
-      );
     }
-    const allowedQuestionTypes = questionTypesForPrompt.map((t4) => `'${t4}'`).join(", ");
-    const codingRequirement = numCodingQuestions > 0 ? `
-**CRITICAL CODING REQUIREMENT**: Exactly ${numCodingQuestions} questions in the plan MUST be of type 'coding'. These should typically be at 'applying' or higher Bloom levels and focus on implementation, debugging, or algorithm design.` : "";
-    const imageContextSection = imageContexts && imageContexts.length > 0 ? `
-## AVAILABLE IMAGE CONTEXT LIBRARY
-You have access to a library of pre-described images. When planning a question, if its subject, category, and topic match an image in this library AND the image's description is relevant to the planned question's topic, you MUST include the corresponding \`imageId\` in your output. Otherwise, leave the \`imageId\` field null or omit it.
-
-\`\`\`json
-${JSON.stringify(imageContexts.map((img) => ({ imageId: img.id, subject: img.subject, category: img.category, topic: img.topic, description: img.detailedDescription })), null, 2)}
-\`\`\`
-` : "";
-    const enhancedPromptText = `You are an elite educational assessment architect with expertise in cognitive science and adaptive learning. Your mission is to create a strategically optimized quiz plan that maximizes learning effectiveness.
-
-${generateQuestionTypeSelectionGuidance()}
-
-${generateAdvancedBloomGuidance()}
-
-${generateDiversityRules()}
-
-## COMPREHENSIVE QUIZ REQUIREMENTS:
-
-**Target Language**: ${language3}
-**Total Questions**: ${totalQuestions}${codingRequirement}
-
-**Topic Distribution & Learning Context** (follow precisely):
-    ${topicsDistribution}
+  }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate FITB question after ${MAX_RETRY_ATTEMPTS6} attempts. Last error: ${lastError?.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
+}
 
-**Cognitive Complexity Distribution** (follow precisely):
-    ${bloomDistribution}
+// src/ai/flows/question-gen/generate-sequence-question.ts
+init_react_shim();
 
-**Available Question Arsenal**: ${allowedQuestionTypes}
+// src/ai/flows/question-gen/generate-sequence-question-types.ts
+init_react_shim();
+BaseQuestionGenerationClientInputSchema.extend({
+  numberOfItems: zod.z.number().int().min(2).max(10).optional().default(4)
+});
+var AISequenceOutputFieldsSchema = zod.z.object({
+  prompt: zod.z.string().describe("The instructional text for the user, e.g., 'Arrange the steps in the correct order.'"),
+  // Yêu cầu AI cung cấp các item dưới dạng một mảng duy nhất đã được sắp xếp đúng thứ tự
+  // Điều này đơn giản hóa logic và giảm rủi ro
+  itemsInCorrectOrder: zod.z.array(zod.z.string().min(1)).min(2).describe("An array of strings, with each string representing an item to be sequenced. The array itself MUST be in the correct final order."),
+  explanation: zod.z.string().optional(),
+  points: zod.z.number().optional().default(10),
+  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: zod.z.string().optional(),
+  verifiedCategory: zod.z.string().optional()
+  // Thêm để xác thực
+});
 
-**Image Resources**: ${imageContextSection} 
+// src/ai/flows/question-gen/generate-sequence-question.ts
+var MAX_RETRY_ATTEMPTS7 = 3;
+var RETRY_DELAY_MS7 = 3e3;
+function buildEnhancedPrompt7(clientInput, attemptNumber) {
+  const { quizContext, language: language3, difficulty, numberOfItems, imageUrl } = clientInput;
+  const category = quizContext?.originalCategory || "the specified technical category";
+  const attemptInfo = attemptNumber > 1 ? `
+## DEBUG INFO - This is attempt #${attemptNumber}
+Previous attempts failed. Ensure the 'itemsInCorrectOrder' array has exactly the required number of items and the JSON is valid.
 
-## STRATEGIC PLANNING METHODOLOGY:
+` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The sequence of items must be directly related to the process or content shown in this image.` : "";
+  const contextStrings = [
+    `**Required Category:** ${category}`,
+    quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    quizContext?.targetMisconception && `**Target Misconception:** The sequence should clarify this specific process error: "${quizContext.targetMisconception}"`
+  ].filter(Boolean).map((s4) => `- ${s4}`).join("\n");
+  const exampleJson = JSON.stringify({
+    prompt: "Arrange the steps to make a network request in Swift using URLSession.",
+    itemsInCorrectOrder: [
+      "Create a URL object.",
+      "Create a URLSessionDataTask with the URL.",
+      "Start the task by calling its resume() method.",
+      "Handle the completion handler with data, response, and error."
+    ],
+    explanation: "This is the fundamental sequence for a basic data task in URLSession.",
+    points: 10,
+    difficulty: "medium",
+    topic: "Swift Networking",
+    verifiedCategory: category
+  }, null, 2);
+  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
+Your mission is to create a high-quality, technically accurate Sequence Question.
 
-1. **Misconception Analysis**: If common misconceptions are provided, design questions specifically to address and correct them
-2. **Question Type Intelligence**: Select question types based on the cognitive demands and content nature
-3. **Difficulty Orchestration**: Create a learning journey that builds confidence while challenging appropriately
-4. **Diversity Optimization**: Ensure variety prevents monotony and maintains engagement
-5. **Context Sensitivity**: Match question types to topic characteristics (technical, conceptual, procedural)
-6. **Image Context Integration**: Intelligently associate questions with relevant images from the provided library to enhance contextual understanding.
+## Core Rules (Non-negotiable)
+1.  **Category Purity:** The question MUST be exclusively about **${category}**.
+2.  **Unambiguous Order:** The items MUST represent a clear, objective process, timeline, or order with only one correct sequence.
+3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object that strictly follows the provided schema.
 
-## ENHANCED OUTPUT FORMAT:
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
 
-Return ONLY a JSON object with this EXACT structure:
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Sequence Question.
 
-\`\`\`json
-{
-  "quizPlan": [
-   {
-      "plannedTopic": "Specific, assessable topic derived from provided context",
-      "plannedQuestionType": "question_type_from_allowed_list",
-      "plannedBloomLevel": "bloom_level_from_requirements",
-      "plannedContextId": "THEO_ABS",
-      "imageId": "imgctx_12345abcde", // or null
-      "targetMisconception": "Specific misconception this question addresses (or 'none' if not applicable)",
-      "difficultyReason": "Strategic explanation of difficulty choice and placement",
-      "topicSpecificity": "broad|focused|specific",
-      "originalLoId": "corresponding_LoId_from_input",
-      "originalSubject": "corresponding_Subject_from_input",
-      "originalCategory": "corresponding_Category_from_input",
-      "originalTopic": "corresponding_Topic_from_input"
-    }
-  ],
-  "diversityMetrics": {
-    "questionTypeDistribution": {"type1": count1, "type2": count2},
-    "bloomLevelDistribution": {"level1": count1, "level2": count2},
-    "maxConsecutiveSameType": number,
-    "difficultyProgression": "description of how difficulty progresses",
-    "misconceptionCoverage": number_of_misconceptions_addressed
-  },
-  "planningStrategy": {
-    "overallApproach": "Brief description of the strategic approach taken",
-    "keyDecisions": ["Major decision 1", "Major decision 2", "Major decision 3"]
-  }
-}
-\`\`\`
+### Input Parameters
+- **Topic for Question:** ${quizContext?.plannedTopic || "General"}
+- **Language for Text:** ${language3}
+- **Difficulty Level:** ${difficulty}
+- **Number of Items:** Generate an array 'itemsInCorrectOrder' containing exactly ${numberOfItems} items. The array itself MUST be in the correct final sequence.
 
-Execute this plan with pedagogical precision. The quiz should feel like a carefully crafted learning journey that challenges and educates simultaneously.`;
-    logger.log("PROMPT_PREPARATION", {
-      promptLength: enhancedPromptText.length,
-      topicCount: clientInput.topics.length,
-      misconceptionCount: clientInput.topics.reduce((sum, t4) => sum + (t4.commonMisconceptions?.length || 0), 0)
-    }, Date.now() - promptStartTime);
-    const generationStartTime = Date.now();
-    const contents = [
-      {
-        role: "user",
-        parts: [
-          {
-            text: enhancedPromptText
-          }
-        ]
-      }
-    ];
-    const aiResult = await ai.models.generateContent({
-      model,
-      config: config3,
-      contents
-    });
-    const response = aiResult;
-    const generationDuration = Date.now() - generationStartTime;
-    logger.log("AI_GENERATION", {
-      responseLength: response.candidates?.[0]?.content?.parts?.[0]?.text?.length || 0,
-      duration: generationDuration
-    }, generationDuration);
-    const processingStartTime = Date.now();
-    const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
-    let jsonText = rawText;
-    if (!rawText.trim().startsWith("{") && !rawText.trim().startsWith("[")) {
-      jsonText = extractJsonFromMarkdown(rawText);
-    }
-    logger.log("JSON_EXTRACTION", {
-      rawTextLength: rawText.length,
-      extractedJsonLength: jsonText.length
-    });
-    const aiGeneratedContent = GenerateQuizPlanOutputSchema.parse(JSON.parse(jsonText));
-    logger.log("SCHEMA_VALIDATION", { success: true }, Date.now() - processingStartTime);
-    const validationStartTime = Date.now();
-    if (aiGeneratedContent.quizPlan.length !== clientInput.totalQuestions) {
-      throw new Error(`AI planned for ${aiGeneratedContent.quizPlan.length} questions, but ${clientInput.totalQuestions} were requested.`);
+### Required JSON Output Format
+Your response must be ONLY the JSON object, matching this exact structure:
+
+${exampleJson}
+
+Now, generate the JSON for the requested question.`;
+}
+async function generateSequenceQuestion(clientInput, apiKey) {
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config3 = {
+    temperature: 0.7,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
     }
-    const invalidTypes = [];
-    aiGeneratedContent.quizPlan.forEach((item, index3) => {
-      if (!clientInput.selectedQuestionTypes.includes(item.plannedQuestionType)) {
-        invalidTypes.push(`Question ${index3 + 1}: '${item.plannedQuestionType}'`);
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS7; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt7(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
+      const parts = [{ text: promptText }];
+      if (clientInput.imageUrl) {
+        const mimeType = clientInput.imageUrl.endsWith(".png") ? "image/png" : "image/jpeg";
+        const imagePart = await urlToGenerativePart(clientInput.imageUrl, mimeType);
+        parts.unshift(imagePart);
       }
-    });
-    if (invalidTypes.length > 0) {
-      throw new Error(`Invalid question types found: ${invalidTypes.join(", ")}`);
-    }
-    const codingQuestions = aiGeneratedContent.quizPlan.filter((q2) => q2.plannedQuestionType === "coding");
-    if (numCodingQuestions > 0 && codingQuestions.length !== numCodingQuestions) {
-      throw new Error(`Expected ${numCodingQuestions} coding questions, but got ${codingQuestions.length}`);
-    }
-    const diversityAnalysis = validateConsecutiveTypes(aiGeneratedContent.quizPlan);
-    logger.log("VALIDATION_COMPLETE", {
-      questionCount: aiGeneratedContent.quizPlan.length,
-      codingQuestionCount: codingQuestions.length,
-      maxConsecutiveType: diversityAnalysis.maxConsecutive,
-      questionTypeDistribution: aiGeneratedContent.diversityMetrics?.questionTypeDistribution || {}
-    }, Date.now() - validationStartTime);
-    const finalResult = {
-      ...aiGeneratedContent,
-      logs: logger.getLogs()
-    };
-    logger.log("GENERATION_COMPLETE", {
-      totalDuration: logger.getTotalDuration(),
-      success: true,
-      finalQuestionCount: finalResult.quizPlan.length
-    }, logger.getTotalDuration());
-    console.log("\n=== QUIZ PLAN GENERATION SUMMARY ===");
-    console.log(`\u2705 Successfully generated ${finalResult.quizPlan.length} questions`);
-    console.log(`\u23F1\uFE0F Total generation time: ${logger.getTotalDuration()}ms`);
-    console.log(`\u{1F3AF} Question types: ${Object.keys(finalResult.diversityMetrics?.questionTypeDistribution || {}).join(", ")}`);
-    console.log(`\u{1F9E0} Bloom levels: ${Object.keys(finalResult.diversityMetrics?.bloomLevelDistribution || {}).join(", ")}`);
-    if (numCodingQuestions > 0) {
-      console.log(`\u{1F4BB} Coding questions: ${codingQuestions.length}/${numCodingQuestions} required`);
-    }
-    console.log(JSON.stringify(finalResult));
-    console.log("=====================================\n");
-    return finalResult;
-  } catch (error) {
-    logger.log("ERROR", {
-      message: error.message,
-      stack: error.stack,
-      totalDuration: logger.getTotalDuration()
-    });
-    console.error("\u274C Quiz Plan Generation Failed:", error.message);
-    console.error("\u{1F4CB} Full logs available in returned object");
-    throw new Error(`Failed to generate Quiz Plan: ${error.message}`);
-  }
-}
-function validateConsecutiveTypes(quizPlan) {
-  let maxConsecutive = 1;
-  let maxType = quizPlan[0]?.plannedQuestionType || "";
-  let maxStartIndex = 0;
-  let currentConsecutive = 1;
-  let currentType = quizPlan[0]?.plannedQuestionType || "";
-  let currentStartIndex = 0;
-  for (let i2 = 1; i2 < quizPlan.length; i2++) {
-    if (quizPlan[i2].plannedQuestionType === currentType) {
-      currentConsecutive++;
-    } else {
-      if (currentConsecutive > maxConsecutive) {
-        maxConsecutive = currentConsecutive;
-        maxType = currentType;
-        maxStartIndex = currentStartIndex;
+      const contents = [{ role: "user", parts }];
+      const aiResult = await ai.models.generateContent({ model, config: config3, contents });
+      const response = aiResult;
+      const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
+      const duration = Date.now() - startTime;
+      DebugLogger.logResponse(attempt, rawText);
+      if (!rawText) throw new Error("AI returned an empty response.");
+      const parsedJson = JSON.parse(rawText);
+      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
+      const aiGeneratedContent = AISequenceOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      if (aiGeneratedContent.itemsInCorrectOrder.length !== clientInput.numberOfItems) {
+        throw new Error(`AI generated ${aiGeneratedContent.itemsInCorrectOrder.length} items, but ${clientInput.numberOfItems} were required.`);
+      }
+      if (clientInput.quizContext?.originalCategory) {
+        const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
+      const finalItems = [];
+      const finalCorrectOrder = [];
+      aiGeneratedContent.itemsInCorrectOrder.forEach((content4) => {
+        const id3 = generateUniqueId("seqi_");
+        finalItems.push({ id: id3, content: content4 });
+        finalCorrectOrder.push(id3);
+      });
+      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.quizContext?.originalTopic,
+        difficulty: clientInput.difficulty,
+        contextCode: clientInput.quizContext?.plannedContextId,
+        bloomLevel: clientInput.quizContext?.plannedBloomLevel,
+        learningObjective: clientInput.quizContext?.originalLoId,
+        subject: clientInput.quizContext?.originalSubject,
+        category: clientInput.quizContext?.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      const validatedQuestion = SequenceQuestionZodSchema.parse(completeQuestion);
+      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
+      console.log(`
+\u2705 Sequence generation successful on attempt ${attempt} (${duration}ms)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } catch (error) {
+      lastError = error;
+      const duration = Date.now() - startTime;
+      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS7;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS7}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS7));
       }
-      currentConsecutive = 1;
-      currentType = quizPlan[i2].plannedQuestionType;
-      currentStartIndex = i2;
     }
   }
-  if (currentConsecutive > maxConsecutive) {
-    maxConsecutive = currentConsecutive;
-    maxType = currentType;
-    maxStartIndex = currentStartIndex;
-  }
-  return {
-    maxConsecutive,
-    type: maxType,
-    startIndex: maxStartIndex
-  };
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate Sequence question after ${MAX_RETRY_ATTEMPTS7} attempts. Last error: ${lastError?.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
 }
 
-// src/ai/flows/generate-questions-from-quiz-plan.ts
+// src/ai/flows/question-gen/generate-matching-question.ts
 init_react_shim();
 
-// src/services/TopicDataService.ts
+// src/ai/flows/question-gen/generate-matching-question-types.ts
 init_react_shim();
-var TopicDataService = class {
-  /**
-   * Saves an array of LearningObjective objects to Local Storage, overwriting existing data.
-   * @param data The array of learning objectives to save.
-   */
-  static saveData(data) {
-    try {
-      if (typeof window === "undefined") return;
-      const serializedData = JSON.stringify(data);
-      localStorage.setItem(this.STORAGE_KEY, serializedData);
-    } catch (error) {
-      console.error("Error saving learning objectives to Local Storage:", error);
-    }
-  }
-  /**
-   * Merges a new set of learning objectives with the existing data in Local Storage.
-   * If an LO ID from newData already exists, it will be updated. Otherwise, it will be added.
-   * @param newData The array of new or updated learning objectives.
-   */
-  static mergeData(newData) {
-    const existingData = this.getData();
-    const loMap = new Map(existingData.map((lo) => [lo.loId, lo]));
-    newData.forEach((newLo) => {
-      loMap.set(newLo.loId, newLo);
-    });
-    const mergedData = Array.from(loMap.values());
-    this.saveData(mergedData);
-  }
-  /**
-   * Retrieves the array of LearningObjective objects from Local Storage.
-   * @returns An array of learning objectives, or an empty array if none are found or an error occurs.
-   */
-  static getData() {
-    try {
-      if (typeof window === "undefined") return [];
-      const storedData = localStorage.getItem(this.STORAGE_KEY);
-      return storedData ? JSON.parse(storedData) : [];
-    } catch (error) {
-      console.error("Error retrieving learning objectives from Local Storage:", error);
-      this.clearData();
-      return [];
+BaseQuestionGenerationClientInputSchema.extend({
+  numberOfPairs: zod.z.number().int().min(2).max(8).optional().default(4),
+  shuffleOptions: zod.z.boolean().optional().default(true)
+});
+var AIMatchingOutputFieldsSchema = zod.z.object({
+  prompt: zod.z.string().describe("The instructional text for the user, e.g., 'Match the concept to its definition.'"),
+  correctPairs: zod.z.array(zod.z.object({
+    promptText: zod.z.string().min(1).describe("The text for the left-hand side item (the prompt)."),
+    optionText: zod.z.string().min(1).describe("The text for the right-hand side item (the matching option).")
+  })).min(2),
+  explanation: zod.z.string().optional(),
+  points: zod.z.number().optional().default(10),
+  difficulty: zod.z.enum(["easy", "medium", "hard"]).optional(),
+  topic: zod.z.string().optional(),
+  verifiedCategory: zod.z.string().optional()
+  // Thêm để xác thực
+});
+
+// src/ai/flows/question-gen/generate-matching-question.ts
+var MAX_RETRY_ATTEMPTS8 = 3;
+var RETRY_DELAY_MS8 = 3e3;
+function buildEnhancedPrompt8(clientInput, attemptNumber) {
+  const { quizContext, language: language3, difficulty, numberOfPairs, imageUrl } = clientInput;
+  const category = quizContext?.originalCategory || "the specified technical category";
+  const attemptInfo = attemptNumber > 1 ? `
+## DEBUG INFO - This is attempt #${attemptNumber}
+Previous attempts failed. Please ensure the 'correctPairs' array has exactly the required number of items and the JSON is valid.
+
+` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The matching pairs must be directly related to the content of this image.` : "";
+  const contextStrings = [
+    `**Required Category:** ${category}`,
+    quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    quizContext?.targetMisconception && `**Target Misconception:** Design a pair that specifically tests this confusion: "${quizContext.targetMisconception}"`
+  ].filter(Boolean).map((s4) => `- ${s4}`).join("\n");
+  const exampleJson = JSON.stringify({
+    prompt: "Match each Swift collection type to its primary characteristic.",
+    correctPairs: [
+      { "promptText": "Array", "optionText": "An ordered, random-access collection." },
+      { "promptText": "Set", "optionText": "An unordered collection of unique elements." },
+      { "promptText": "Dictionary", "optionText": "An unordered collection of key-value associations." }
+    ],
+    explanation: "These are the fundamental characteristics of Swift's main collection types.",
+    points: 10,
+    difficulty: "easy",
+    topic: "Swift Collection Types",
+    verifiedCategory: category
+  }, null, 2);
+  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
+Your mission is to create a high-quality, technically accurate Matching Question.
+
+## Core Rules (Non-negotiable)
+1.  **Category Purity:** The question MUST be exclusively about **${category}**.
+2.  **Logical Pairs:** The items to be matched must have a clear, one-to-one relationship.
+3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object that strictly follows the provided schema.
+
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Matching Question.
+
+### Input Parameters
+- **Topic for Question:** ${quizContext?.plannedTopic || "General"}
+- **Language for Text:** ${language3}
+- **Difficulty Level:** ${difficulty}
+- **Number of Pairs:** Generate exactly ${numberOfPairs} correct pairs in the 'correctPairs' array.
+
+### Required JSON Output Format
+Your response must be ONLY the JSON object, matching this exact structure:
+
+${exampleJson}
+
+Now, generate the JSON for the requested question.`;
+}
+async function generateMatchingQuestion(clientInput, apiKey) {
+  const ai = new genai.GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config3 = {
+    temperature: 0.8,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
     }
-  }
-  /**
-   * Removes all learning objective data from Local Storage.
-   */
-  static clearData() {
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS8; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt8(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
     try {
-      if (typeof window === "undefined") return;
-      localStorage.removeItem(this.STORAGE_KEY);
-    } catch (error) {
-      console.error("Error clearing learning objectives from Local Storage:", error);
-    }
-  }
-  /**
-   * Parses TSV content into an array of LearningObjective objects.
-   * @param tsvContent The raw string content from a .tsv file.
-   * @returns An object containing the successfully parsed data and any errors encountered.
-   */
-  static parseTSV(tsvContent) {
-    const lines = tsvContent.split("\n").filter((line) => line.trim() !== "");
-    if (lines.length < 2) {
-      return { data: [], errors: ["File is empty or contains only a header."] };
-    }
-    const headerLine = lines.shift();
-    const headers = headerLine.split("	").map((h3) => h3.trim());
-    if (headers.length !== this.EXPECTED_HEADERS.length || !this.EXPECTED_HEADERS.every((h3, i2) => h3 === headers[i2])) {
-      const errorMsg = `Invalid TSV header. Expected: "${this.EXPECTED_HEADERS.join("	")}". Received: "${headers.join("	")}"`;
-      return { data: [], errors: [errorMsg] };
-    }
-    const data = [];
-    const errors2 = [];
-    lines.forEach((line, index3) => {
-      const values = line.split("	").map((v) => v.trim());
-      if (values.length !== this.EXPECTED_HEADERS.length) {
-        errors2.push(`Line ${index3 + 2}: Incorrect number of columns. Expected ${this.EXPECTED_HEADERS.length}, but got ${values.length}.`);
-        return;
+      DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
+      const parts = [{ text: promptText }];
+      if (clientInput.imageUrl) {
+        const mimeType = clientInput.imageUrl.endsWith(".png") ? "image/png" : "image/jpeg";
+        const imagePart = await urlToGenerativePart(clientInput.imageUrl, mimeType);
+        parts.unshift(imagePart);
       }
-      const [
-        loId,
-        loDescription,
-        subject,
-        category,
-        topic,
-        keywordsStr,
-        grade,
-        stemElementsStr,
-        bloomLevelsStr
-      ] = values;
-      if (!loId || !subject || !category || !topic) {
-        errors2.push(`Line ${index3 + 2}: Missing required fields (LO ID, Subject, Category, or Topic).`);
-        return;
+      const contents = [{ role: "user", parts }];
+      const aiResult = await ai.models.generateContent({ model, config: config3, contents });
+      const response = aiResult;
+      const rawText = response.candidates?.[0]?.content?.parts?.[0]?.text || "";
+      const duration = Date.now() - startTime;
+      DebugLogger.logResponse(attempt, rawText);
+      if (!rawText) throw new Error("AI returned an empty response.");
+      const parsedJson = JSON.parse(rawText);
+      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
+      const aiGeneratedContent = AIMatchingOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      if (aiGeneratedContent.correctPairs.length !== clientInput.numberOfPairs) {
+        throw new Error(`AI generated ${aiGeneratedContent.correctPairs.length} pairs, but ${clientInput.numberOfPairs} were required.`);
       }
-      const learningObjective = {
-        loId,
-        loDescription,
-        subject,
-        category,
-        topic,
-        keywords: keywordsStr.split(",").map((k3) => k3.trim()).filter(Boolean),
-        grade,
-        stemElements: stemElementsStr.split(",").map((s4) => s4.trim()).filter(Boolean),
-        bloomLevelsGuideline: bloomLevelsStr.split(",").map((b2) => b2.trim()).filter(Boolean)
+      if (clientInput.quizContext?.originalCategory) {
+        const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
+      const finalPrompts = [];
+      const finalOptions = [];
+      const finalCorrectAnswerMap = [];
+      aiGeneratedContent.correctPairs.forEach((pair2) => {
+        const promptId = generateUniqueId("m_p_");
+        const optionId = generateUniqueId("m_o_");
+        finalPrompts.push({ id: promptId, content: pair2.promptText });
+        finalOptions.push({ id: optionId, content: pair2.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.quizContext?.originalTopic,
+        difficulty: clientInput.difficulty,
+        contextCode: clientInput.quizContext?.plannedContextId,
+        bloomLevel: clientInput.quizContext?.plannedBloomLevel,
+        learningObjective: clientInput.quizContext?.originalLoId,
+        subject: clientInput.quizContext?.originalSubject,
+        category: clientInput.quizContext?.originalCategory,
+        imageUrl: clientInput.imageUrl
       };
-      data.push(learningObjective);
-    });
-    return { data, errors: errors2 };
-  }
-  /**
-   * Gets a unique list of all subjects from the stored data.
-   * @returns An array of subject strings.
-   */
-  static getSubjects() {
-    const data = this.getData();
-    const subjects = data.map((item) => item.subject);
-    return [...new Set(subjects)].sort();
-  }
-  /**
-   * Gets a unique list of categories for a given subject.
-   * @param subject The subject to filter by.
-   * @returns An array of category strings.
-   */
-  static getCategoriesBySubject(subject) {
-    const data = this.getData();
-    const categories = data.filter((item) => item.subject === subject).map((item) => item.category);
-    return [...new Set(categories)].sort();
-  }
-  /**
-   * Gets a unique list of topics for a given category.
-   * @param category The category to filter by.
-   * @returns An array of topic strings.
-   */
-  static getTopicsByCategory(category) {
-    const data = this.getData();
-    const topics = data.filter((item) => item.category === category).map((item) => item.topic);
-    return [...new Set(topics)].sort();
-  }
-  /**
-   * Retrieves all LearningObjective details for a given list of topics.
-   * @param topics An array of topic strings to search for.
-   * @returns An array of matching LearningObjective objects.
-   */
-  static getLearningObjectivesByTopics(topics) {
-    const data = this.getData();
-    const topicSet = new Set(topics);
-    return data.filter((item) => topicSet.has(item.topic));
+      const validatedQuestion = MatchingQuestionZodSchema.parse(completeQuestion);
+      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
+      console.log(`
+\u2705 Matching generation successful on attempt ${attempt} (${duration}ms)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } catch (error) {
+      lastError = error;
+      const duration = Date.now() - startTime;
+      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS8;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS8}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS8));
+      }
+    }
   }
-};
-TopicDataService.STORAGE_KEY = "interactive_quiz_kit_learning_objectives";
-TopicDataService.EXPECTED_HEADERS = [
-  "LO ID",
-  "LO Description",
-  "Subject",
-  "Category",
-  "Topic",
-  "Keywords",
-  "Grade",
-  "STEM Element(s)",
-  "Bloom\u2019s Level(s) Guideline"
-];
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate Matching question after ${MAX_RETRY_ATTEMPTS8} attempts. Last error: ${lastError?.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
+}
 
 // src/ai/flows/question-gen/generate-coding-question.ts
 init_react_shim();
@@ -102350,7 +102196,7 @@ async function generateCodingQuestion(clientInput, apiKey) {
 var MAX_ATTEMPTS = 3;
 var RETRY_DELAY_MS10 = 2e3;
 var delay = (ms) => new Promise((res) => setTimeout(res, ms));
-var calculateCombinedDifficulty2 = (plannedQ) => {
+var calculateCombinedDifficulty = (plannedQ) => {
   const { plannedBloomLevel, plannedQuestionType, plannedContextId } = plannedQ;
   let contextScore = 1;
   if (["SPEC_CASE", "NAT_OBS", "DATA_MOD", "INTERDISC", "HYPO_COMP"].includes(plannedContextId || "")) contextScore = 2;
@@ -102407,7 +102253,7 @@ async function generateQuestionsFromQuizPlan(clientInput, apiKey) {
         const imageUrl = plannedQ.imageId && imageContexts ? imageContexts.find((ctx) => ctx.id === plannedQ.imageId)?.imageUrl : void 0;
         const baseClientInput = {
           language: language3,
-          difficulty: calculateCombinedDifficulty2(plannedQ),
+          difficulty: calculateCombinedDifficulty(plannedQ),
           quizContext,
           imageUrl
         };
@@ -102489,6 +102335,22 @@ async function generateQuestionsFromQuizPlan(clientInput, apiKey) {
   return { generatedQuestions, errors: errors2.length > 0 ? errors2 : void 0 };
 }
 
+// src/data/contextOptions.ts
+init_react_shim();
+var contextOptions = [
+  { shortContextId: "A", contextId: "THEO_ABS", contextDescription: "L\xFD thuy\u1EBFt/Tr\u1EEBu t\u01B0\u1EE3ng", contextExample: '"Ph\xE1t bi\u1EC3u \u0111\u1ECBnh lu\u1EADt III Newton." ho\u1EB7c "Gi\u1EA3i th\xEDch kh\xE1i ni\u1EC7m \u0111\u1EA1o h\xE0m."', keywords: "l\xFD thuy\u1EBFt, tr\u1EEBu t\u01B0\u1EE3ng, \u0111\u1ECBnh ngh\u0129a, kh\xE1i ni\u1EC7m, nguy\xEAn l\xFD, c\xF4ng th\u1EE9c, \u0111\u1ECBnh lu\u1EADt" },
+  { shortContextId: "B", contextId: "SPEC_CASE", contextDescription: "V\xED d\u1EE5 C\u1EE5 th\u1EC3/Tr\u01B0\u1EDDng h\u1EE3p Ri\xEAng", contextExample: '"T\xEDnh l\u1EF1c t\xE1c d\u1EE5ng l\xEAn v\u1EADt n\u1EB7ng 2kg r\u01A1i t\u1EF1 do." ho\u1EB7c "Cho h\xE0m s\u1ED1 y = x^2, t\xECm \u0111\u1EA1o h\xE0m t\u1EA1i x = 3."', keywords: "v\xED d\u1EE5, c\u1EE5 th\u1EC3, tr\u01B0\u1EDDng h\u1EE3p ri\xEAng, \xE1p d\u1EE5ng, t\xEDnh to\xE1n, minh h\u1ECDa, s\u1ED1 li\u1EC7u c\u1EE5 th\u1EC3" },
+  { shortContextId: "C", contextId: "NAT_OBS", contextDescription: "Hi\u1EC7n t\u01B0\u1EE3ng T\u1EF1 nhi\xEAn/Quan s\xE1t", contextExample: '"Gi\u1EA3i th\xEDch t\u1EA1i sao c\u1EA7u v\u1ED3ng xu\u1EA5t hi\u1EC7n sau c\u01A1n m\u01B0a." ho\u1EB7c "M\xF4 t\u1EA3 qu\xE1 tr\xECnh quang h\u1EE3p \u1EDF l\xE1 c\xE2y."', keywords: "hi\u1EC7n t\u01B0\u1EE3ng, t\u1EF1 nhi\xEAn, quan s\xE1t, gi\u1EA3i th\xEDch, m\xF4 t\u1EA3, th\u1EBF gi\u1EDBi th\u1EF1c, sinh h\u1ECDc, v\u1EADt l\xFD" },
+  { shortContextId: "D", contextId: "TECH_ENG", contextDescription: "\u1EE8ng d\u1EE5ng C\xF4ng ngh\u1EC7/K\u1EF9 thu\u1EADt", contextExample: '"Nguy\xEAn l\xFD ho\u1EA1t \u0111\u1ED9ng c\u1EE7a \u0111\u1ED9ng c\u01A1 \u0111\u1ED1t trong l\xE0 g\xEC?" ho\u1EB7c "Pin m\u1EB7t tr\u1EDDi chuy\u1EC3n \u0111\u1ED5i n\u0103ng l\u01B0\u1EE3ng \xE1nh s\xE1ng th\xE0nh \u0111i\u1EC7n n\u0103ng nh\u01B0 th\u1EBF n\xE0o?"', keywords: "\u1EE9ng d\u1EE5ng, c\xF4ng ngh\u1EC7, k\u1EF9 thu\u1EADt, thi\u1EBFt b\u1ECB, m\xE1y m\xF3c, ho\u1EA1t \u0111\u1ED9ng, nguy\xEAn l\xFD, ch\u1EBF t\u1EA1o" },
+  { shortContextId: "E", contextId: "EXP_INV", contextDescription: "Th\xED nghi\u1EC7m/\u0110i\u1EC1u tra Khoa h\u1ECDc", contextExample: '"Thi\u1EBFt k\u1EBF th\xED nghi\u1EC7m ch\u1EE9ng minh \u0111\u1ECBnh lu\u1EADt b\u1EA3o to\xE0n n\u0103ng l\u01B0\u1EE3ng." ho\u1EB7c "Ph\xE2n t\xEDch k\u1EBFt qu\u1EA3 th\xED nghi\u1EC7m v\u1EC1 t\u1ED1c \u0111\u1ED9 ph\u1EA3n \u1EE9ng."', keywords: "th\xED nghi\u1EC7m, \u0111i\u1EC1u tra, khoa h\u1ECDc, thi\u1EBFt k\u1EBF, quy tr\xECnh, k\u1EBFt qu\u1EA3, ph\xE2n t\xEDch, d\u1EEF li\u1EC7u" },
+  { shortContextId: "F", contextId: "REAL_PROB", contextDescription: "V\u1EA5n \u0111\u1EC1 Th\u1EF1c t\u1EBF/X\xE3 h\u1ED9i/M\xF4i tr\u01B0\u1EDDng", contextExample: '"\u0110\u1EC1 xu\u1EA5t gi\u1EA3i ph\xE1p gi\u1EA3m thi\u1EC3u \xF4 nhi\u1EC5m kh\xF4ng kh\xED t\u1EA1i \u0111\xF4 th\u1ECB." ho\u1EB7c "Ph\xE2n t\xEDch \u1EA3nh h\u01B0\u1EDFng c\u1EE7a bi\u1EBFn \u0111\u1ED5i kh\xED h\u1EADu \u0111\u1EBFn n\xF4ng nghi\u1EC7p."', keywords: "v\u1EA5n \u0111\u1EC1, th\u1EF1c t\u1EBF, x\xE3 h\u1ED9i, m\xF4i tr\u01B0\u1EDDng, gi\u1EA3i ph\xE1p, ph\xE2n t\xEDch, \u1EA3nh h\u01B0\u1EDFng, b\u1EC1n v\u1EEFng" },
+  { shortContextId: "G", contextId: "DATA_MOD", contextDescription: "Di\u1EC5n gi\u1EA3i D\u1EEF li\u1EC7u/M\xF4 h\xECnh h\xF3a", contextExample: '"D\u1EF1a v\xE0o bi\u1EC3u \u0111\u1ED3, nh\u1EADn x\xE9t xu h\u01B0\u1EDBng nhi\u1EC7t \u0111\u1ED9 to\xE0n c\u1EA7u." ho\u1EB7c "X\xE2y d\u1EF1ng m\xF4 h\xECnh to\xE1n h\u1ECDc m\xF4 t\u1EA3 s\u1EF1 t\u0103ng tr\u01B0\u1EDFng d\xE2n s\u1ED1."', keywords: "d\u1EEF li\u1EC7u, bi\u1EC3u \u0111\u1ED3, b\u1EA3ng s\u1ED1 li\u1EC7u, m\xF4 h\xECnh, di\u1EC5n gi\u1EA3i, ph\xE2n t\xEDch, xu h\u01B0\u1EDBng, d\u1EF1 \u0111o\xE1n" },
+  { shortContextId: "H", contextId: "HIST_SCI", contextDescription: "L\u1ECBch s\u1EED/Ph\xE1t tri\u1EC3n Khoa h\u1ECDc", contextExample: '"Tr\xECnh b\xE0y b\u1ED1i c\u1EA3nh ra \u0111\u1EDDi thuy\u1EBFt t\u01B0\u01A1ng \u0111\u1ED1i c\u1EE7a Einstein." ho\u1EB7c "Ai l\xE0 ng\u01B0\u1EDDi \u0111\u1EA7u ti\xEAn ph\xE1t hi\u1EC7n ra c\u1EA5u tr\xFAc DNA?"', keywords: "l\u1ECBch s\u1EED, ph\xE1t tri\u1EC3n, khoa h\u1ECDc, nh\xE0 khoa h\u1ECDc, ph\xE1t minh, kh\xE1m ph\xE1, b\u1ED1i c\u1EA3nh" },
+  { shortContextId: "I", contextId: "INTERDISC", contextDescription: "Li\xEAn ng\xE0nh (Interdisciplinary)", contextExample: '"S\u1EED d\u1EE5ng ki\u1EBFn th\u1EE9c To\xE1n v\xE0 V\u1EADt l\xFD \u0111\u1EC3 t\xEDnh qu\u1EF9 \u0111\u1EA1o c\u1EE7a v\u1EADt n\xE9m xi\xEAn." ho\u1EB7c "Ph\xE2n t\xEDch c\u01A1 ch\u1EBF h\xF3a sinh c\u1EE7a qu\xE1 tr\xECnh ti\xEAu h\xF3a."', keywords: "li\xEAn ng\xE0nh, t\xEDch h\u1EE3p, To\xE1n-L\xFD, Sinh-H\xF3a, Khoa h\u1ECDc-C\xF4ng ngh\u1EC7, k\u1EBFt n\u1ED1i ki\u1EBFn th\u1EE9c" },
+  { shortContextId: "J", contextId: "HYPO_COMP", contextDescription: "Gi\u1EA3 \u0111\u1ECBnh/So s\xE1nh T\xECnh hu\u1ED1ng", contextExample: '"N\u1EBFu Tr\xE1i \u0110\u1EA5t kh\xF4ng c\xF3 t\u1EEB tr\u01B0\u1EDDng th\xEC \u0111i\u1EC1u g\xEC s\u1EBD x\u1EA3y ra?" ho\u1EB7c "So s\xE1nh \u01B0u nh\u01B0\u1EE3c \u0111i\u1EC3m c\u1EE7a n\u0103ng l\u01B0\u1EE3ng h\u1EA1t nh\xE2n v\xE0 n\u0103ng l\u01B0\u1EE3ng m\u1EB7t tr\u1EDDi."', keywords: "gi\u1EA3 \u0111\u1ECBnh, so s\xE1nh, t\xECnh hu\u1ED1ng, n\u1EBFu...th\xEC, \u01B0u \u0111i\u1EC3m, nh\u01B0\u1EE3c \u0111i\u1EC3m, ph\xE2n t\xEDch, \u0111\xE1nh gi\xE1" },
+  { shortContextId: "__custom__", contextId: "__custom__", contextDescription: "Other (Custom Input)", contextExample: "", keywords: "custom, other, specific" }
+];
+
 // src/react-ui/components/authoring/AIFullQuizGeneratorModal.tsx
 var availableQuestionTypesForFullQuiz = [
   { value: "true_false", label: "True/False" },