@thanh01.pmt/interactive-quiz-kit 1.0.27 → 1.0.29

package/dist/ai.mjs

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import { genkit } from 'genkit';
 import { gemini20Flash, googleAI } from '@genkit-ai/googleai';
 
-// src/ai/flows/question-gen/generate-fitb-question.ts
+// src/ai/flows/question-gen/generate-true-false-question.ts
 
 // src/utils/idGenerators.ts
 function generateUniqueId(prefix = "id_") {
@@ -196,20 +196,12 @@ var CodingQuestionZodSchema = BaseQuestionZodSchema.extend({
   })).min(1)
 });
 
-// src/ai/flows/question-gen/generate-fitb-question-types.ts
-BaseQuestionGenerationClientInputSchema.extend({
-  numberOfBlanks: z.number().int().min(1).max(5).optional().default(1),
-  isCaseSensitive: z.boolean().optional().default(false)
-});
-var AIFillInTheBlanksOutputFieldsSchema = z.object({
-  prompt: 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: z.array(z.object({
-    type: z.enum(["text", "blank"]),
-    content: z.string().optional().describe("The text content for a 'text' segment."),
-    acceptedAnswers: z.array(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: z.string().optional(),
+// src/ai/flows/question-gen/generate-true-false-question-types.ts
+BaseQuestionGenerationClientInputSchema.extend({});
+var AITrueFalseOutputFieldsSchema = z.object({
+  prompt: z.string().describe("The statement that the user will evaluate as true or false."),
+  correctAnswer: z.boolean(),
+  explanation: z.string().optional().describe("An explanation of why the statement is true or false, especially important if false."),
   points: z.number().optional().default(10),
   difficulty: z.enum(["easy", "medium", "hard"]).optional(),
   topic: z.string().optional(),
@@ -217,57 +209,55 @@ var AIFillInTheBlanksOutputFieldsSchema = z.object({
   // Thêm để xác thực
 });
 
-// src/ai/flows/question-gen/generate-fitb-question.ts
+// src/ai/flows/question-gen/generate-true-false-question.ts
 var MAX_RETRY_ATTEMPTS = 3;
 var RETRY_DELAY_MS = 3e3;
 function buildEnhancedPrompt(clientInput, attemptNumber) {
-  const { quizContext, language, difficulty, numberOfBlanks, imageUrl } = clientInput;
+  const { quizContext, language, difficulty, 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'.
+Previous attempts failed. Ensure the JSON is valid and 'correctAnswer' is a boolean.
 
 ` : "";
-  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 imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The True/False statement must be directly related to the content of this image.` : "";
+  const misconceptionGuidance = quizContext?.targetMisconception ? `**Target Misconception:** The statement you create MUST be FALSE and based on this common mistake: "${quizContext.targetMisconception}"` : "";
   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}"`
+    misconceptionGuidance,
+    quizContext?.difficultyReason && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
   ].filter(Boolean).map((s) => `- ${s}`).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.",
+    prompt: "In Swift, you must explicitly unwrap an Optional value before you can use its stored value.",
+    correctAnswer: true,
+    explanation: "Optional values in Swift represent the presence or absence of a value. To access the value when it exists, you must unwrap it using methods like 'if let', 'guard let', or the force unwrap operator '!'.",
     points: 10,
     difficulty: "easy",
-    topic: "Swift Function Declaration",
+    topic: "Swift Optionals",
     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.
+Your mission is to create a high-quality, technically accurate True/False 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.
+1.  **Category Purity:** The statement ('prompt') MUST be exclusively about **${category}**.
+2.  **Clarity:** The statement must be definitively true or false, with no ambiguity.
+3.  **Misconception Priority:** If a Target Misconception is provided, the statement MUST be FALSE and reflect that misconception. This is a critical rule.
+4.  **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 Fill-in-the-Blanks Question.
+Based on all the rules and context above, generate a single True/False Question.
 
 ### Input Parameters
 - **Topic for Question:** ${quizContext?.plannedTopic || "General"}
 - **Language for Text:** ${language}
 - **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:
@@ -276,11 +266,11 @@ ${exampleJson}
 
 Now, generate the JSON for the requested question.`;
 }
-async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
+async function generateTrueFalseQuestion(clientInput, apiKey) {
   const ai = new GoogleGenAI({ apiKey });
   const model = "gemini-2.5-flash";
   const config = {
-    temperature: 0.8,
+    temperature: 0.6,
     responseMimeType: "application/json",
     thinkingConfig: {
       thinkingBudget: 4e3
@@ -309,20 +299,11 @@ async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
       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);
+      const aiGeneratedContent = AITrueFalseOutputFieldsSchema.parse(parsedJson);
       DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      const blankCount = aiGeneratedContent.segments.filter((s) => s.type === "blank").length;
-      if (blankCount !== clientInput.numberOfBlanks) {
-        throw new Error(`AI generated ${blankCount} blanks, but ${clientInput.numberOfBlanks} were required.`);
+      if (clientInput.quizContext?.targetMisconception && aiGeneratedContent.correctAnswer === true) {
+        throw new Error("AI failed to follow the Misconception Priority rule. The answer should have been false.");
       }
-      aiGeneratedContent.segments.forEach((segment, index) => {
-        if (segment.type === "blank" && (!segment.acceptedAnswers || segment.acceptedAnswers.length === 0)) {
-          throw new Error(`Segment ${index} is a 'blank' but is missing 'acceptedAnswers'.`);
-        }
-        if (segment.type === "text" && typeof segment.content !== "string") {
-          throw new Error(`Segment ${index} is 'text' but is missing 'content'.`);
-        }
-      });
       if (clientInput.quizContext?.originalCategory) {
         const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
         const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
@@ -330,24 +311,11 @@ async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
           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",
+        id: generateUniqueId("tf_ai_"),
+        questionType: "true_false",
         prompt: aiGeneratedContent.prompt,
-        segments: finalSegments,
-        answers: finalAnswers,
-        isCaseSensitive: clientInput.isCaseSensitive,
+        correctAnswer: aiGeneratedContent.correctAnswer,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
         topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
@@ -359,10 +327,10 @@ async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
         category: clientInput.quizContext?.originalCategory,
         imageUrl: clientInput.imageUrl
       };
-      const validatedQuestion = FillInTheBlanksQuestionZodSchema.parse(completeQuestion);
+      const validatedQuestion = TrueFalseQuestionZodSchema.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)`);
+\u2705 True/False generation successful on attempt ${attempt} (${duration}ms)`);
       if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
       return { question: validatedQuestion };
     } catch (error) {
@@ -378,89 +346,93 @@ async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
     }
   }
   DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate FITB question after ${MAX_RETRY_ATTEMPTS} attempts. Last error: ${lastError?.message}`;
+  const errorMessage = `Failed to generate True/False question after ${MAX_RETRY_ATTEMPTS} attempts. Last error: ${lastError?.message}`;
   console.error("\n\u274C Final Result: FAILED");
   console.error(errorMessage);
   return { error: errorMessage };
 }
 BaseQuestionGenerationClientInputSchema.extend({
-  numberOfPairs: z.number().int().min(2).max(8).optional().default(4),
-  shuffleOptions: z.boolean().optional().default(true)
+  numberOfOptions: z.number().int().min(2).max(6).optional().default(4)
 });
-var AIMatchingOutputFieldsSchema = z.object({
-  prompt: z.string().describe("The instructional text for the user, e.g., 'Match the concept to its definition.'"),
-  correctPairs: z.array(z.object({
-    promptText: z.string().min(1).describe("The text for the left-hand side item (the prompt)."),
-    optionText: z.string().min(1).describe("The text for the right-hand side item (the matching option).")
-  })).min(2),
-  explanation: z.string().optional(),
+var AIMCQOutputFieldsSchema = z.object({
+  prompt: z.string().describe("The question statement itself."),
+  options: z.array(
+    z.object({
+      tempId: z.string().describe("A temporary, unique identifier for this option (e.g., 'A', 'B', '1', '2')."),
+      text: z.string().describe("The text content of this answer option.")
+    })
+  ).min(2).max(6),
+  correctTempOptionId: z.string().describe("The temporary ID of the correct option from the generated options array."),
+  explanation: z.string().optional().describe("A brief explanation of why the answer is correct."),
   points: z.number().optional().default(10),
   difficulty: z.enum(["easy", "medium", "hard"]).optional(),
   topic: z.string().optional(),
-  verifiedCategory: z.string().optional()
-  // Thêm để xác thực
+  verifiedCategory: z.string().optional().describe("The category this question actually addresses.")
 });
 
-// src/ai/flows/question-gen/generate-matching-question.ts
+// src/ai/flows/question-gen/generate-mcq-question.ts
 var MAX_RETRY_ATTEMPTS2 = 3;
 var RETRY_DELAY_MS2 = 3e3;
 function buildEnhancedPrompt2(clientInput, attemptNumber) {
-  const { quizContext, language, difficulty, numberOfPairs, imageUrl } = clientInput;
+  const { quizContext, language, difficulty, numberOfOptions, 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...
 
 ` : "";
-  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}`,
     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: "${quizContext.targetMisconception}"`,
+    quizContext?.difficultyReason && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
   ].filter(Boolean).map((s) => `- ${s}`).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: `In ${category}, what is the primary purpose of the 'guard' statement?`,
+    options: [
+      { tempId: "A", text: "To execute a block of code repeatedly." },
+      { tempId: "B", text: "To define a new custom data type." },
+      { tempId: "C", text: "To exit a scope early if a condition is not met." },
+      { tempId: "D", text: "To handle errors thrown by a function." }
     ],
-    explanation: "These are the fundamental characteristics of Swift's main collection types.",
+    correctTempOptionId: "C",
+    explanation: `The 'guard' statement in ${category} provides an early exit from a scope (like a function) if a condition is false, enhancing code readability by handling required conditions upfront.`,
     points: 10,
     difficulty: "easy",
-    topic: "Swift Collection Types",
+    topic: `Control Flow in ${category}`,
     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 Choice 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}**. Do NOT mention or use syntax from other languages.
+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, comments, or markdown formatting.
 
 ## 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 Choice Question.
 
 ### Input Parameters
 - **Topic for Question:** ${quizContext?.plannedTopic || "General"}
 - **Language for Text:** ${language}
 - **Difficulty Level:** ${difficulty}
-- **Number of Pairs:** Generate exactly ${numberOfPairs} correct pairs in the 'correctPairs' array.
+- **Number of Options:** ${numberOfOptions}
 
 ### 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 generateMCQQuestion(clientInput, apiKey) {
   const ai = new GoogleGenAI({ apiKey });
   const model = "gemini-2.5-flash";
   const config = {
@@ -485,19 +457,22 @@ async function generateMatchingQuestion(clientInput, apiKey) {
         parts.unshift(imagePart);
       }
       const contents = [{ role: "user", parts }];
-      const aiResult = await ai.models.generateContent({ model, config, contents });
+      const aiResult = await ai.models.generateContent({
+        model,
+        config,
+        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 = AIMCQOutputFieldsSchema.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 (clientInput.quizContext?.originalCategory) {
         const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
         const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
@@ -505,24 +480,23 @@ async function generateMatchingQuestion(clientInput, apiKey) {
           throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
         }
       }
-      const finalPrompts = [];
       const finalOptions = [];
-      const finalCorrectAnswerMap = [];
-      aiGeneratedContent.correctPairs.forEach((pair) => {
-        const promptId = generateUniqueId("m_p_");
-        const optionId = generateUniqueId("m_o_");
-        finalPrompts.push({ id: promptId, content: pair.promptText });
-        finalOptions.push({ id: optionId, content: pair.optionText });
-        finalCorrectAnswerMap.push({ promptId, optionId });
+      const tempIdToFinalIdMap = {};
+      aiGeneratedContent.options.forEach((aiOption) => {
+        const finalId = generateUniqueId("opt_");
+        finalOptions.push({ id: finalId, text: aiOption.text });
+        tempIdToFinalIdMap[aiOption.tempId] = finalId;
       });
+      const finalCorrectAnswerId = tempIdToFinalIdMap[aiGeneratedContent.correctTempOptionId];
+      if (!finalCorrectAnswerId) {
+        throw new Error(`Correct option ID '${aiGeneratedContent.correctTempOptionId}' is invalid`);
+      }
       const completeQuestion = {
-        id: generateUniqueId("match_ai_"),
-        questionType: "matching",
+        id: generateUniqueId("mcq_ai_"),
+        questionType: "multiple_choice",
         prompt: aiGeneratedContent.prompt,
-        prompts: finalPrompts,
         options: finalOptions,
-        correctAnswerMap: finalCorrectAnswerMap,
-        shuffleOptions: clientInput.shuffleOptions,
+        correctAnswerId: finalCorrectAnswerId,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
         topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
@@ -534,10 +508,10 @@ async function generateMatchingQuestion(clientInput, apiKey) {
         category: clientInput.quizContext?.originalCategory,
         imageUrl: clientInput.imageUrl
       };
-      const validatedQuestion = MatchingQuestionZodSchema.parse(completeQuestion);
+      const validatedQuestion = MultipleChoiceQuestionZodSchema.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)`);
+\u2705 MCQ generation successful on attempt ${attempt} (${duration}ms)`);
       if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
       return { question: validatedQuestion };
     } catch (error) {
@@ -553,84 +527,83 @@ async function generateMatchingQuestion(clientInput, apiKey) {
     }
   }
   DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate Matching question after ${MAX_RETRY_ATTEMPTS2} attempts. Last error: ${lastError?.message}`;
+  const errorMessage = `Failed to generate MCQ question after ${MAX_RETRY_ATTEMPTS2} attempts. Last error: ${lastError?.message}`;
   console.error("\n\u274C Final Result: FAILED");
   console.error(errorMessage);
   return { error: errorMessage };
 }
 BaseQuestionGenerationClientInputSchema.extend({
-  numberOfOptions: z.number().int().min(2).max(6).optional().default(4)
+  numberOfOptions: z.number().int().min(2).max(8).optional().default(5),
+  minCorrectAnswers: z.number().int().min(1).optional().default(2),
+  maxCorrectAnswers: z.number().int().min(1).optional().default(3)
 });
-var AIMCQOutputFieldsSchema = z.object({
-  prompt: z.string().describe("The question statement itself."),
-  options: z.array(
-    z.object({
-      tempId: z.string().describe("A temporary, unique identifier for this option (e.g., 'A', 'B', '1', '2')."),
-      text: z.string().describe("The text content of this answer option.")
-    })
-  ).min(2).max(6),
-  correctTempOptionId: z.string().describe("The temporary ID of the correct option from the generated options array."),
-  explanation: z.string().optional().describe("A brief explanation of why the answer is correct."),
+var AIMRQOutputFieldsSchema = z.object({
+  prompt: z.string(),
+  options: z.array(z.object({ tempId: z.string(), text: z.string() })).min(2).max(8),
+  correctTempOptionIds: z.array(z.string()).min(1),
+  explanation: z.string().optional(),
   points: z.number().optional().default(10),
   difficulty: z.enum(["easy", "medium", "hard"]).optional(),
   topic: z.string().optional(),
   verifiedCategory: z.string().optional().describe("The category this question actually addresses.")
 });
 
-// src/ai/flows/question-gen/generate-mcq-question.ts
+// 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, difficulty, numberOfOptions, imageUrl } = clientInput;
+  const { quizContext, language, 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...
+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 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:** Use this to create plausible incorrect answers: "${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((s) => `- ${s}`).join("\n");
   const exampleJson = JSON.stringify({
-    prompt: `In ${category}, what is the primary purpose of the 'guard' statement?`,
+    prompt: "Which of the following are considered programming paradigms?",
     options: [
-      { tempId: "A", text: "To execute a block of code repeatedly." },
-      { tempId: "B", text: "To define a new custom data type." },
-      { tempId: "C", text: "To exit a scope early if a condition is not met." },
-      { tempId: "D", text: "To handle errors thrown by a function." }
+      { "tempId": "A", "text": "Object-Oriented" },
+      { "tempId": "B", "text": "Assembly" },
+      { "tempId": "C", "text": "Functional" },
+      { "tempId": "D", "text": "Procedural" },
+      { "tempId": "E", "text": "Middleware" }
     ],
-    correctTempOptionId: "C",
-    explanation: `The 'guard' statement in ${category} provides an early exit from a scope (like a function) if a condition is false, enhancing code readability by handling required conditions upfront.`,
+    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: `Control Flow in ${category}`,
+    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 Choice Question. You must adhere to the following rules at all times.
+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, options, and explanation MUST be exclusively about **${category}**. Do NOT mention or use syntax from other languages.
+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, comments, or markdown formatting.
+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 Multiple Choice 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:** ${language}
 - **Difficulty Level:** ${difficulty}
-- **Number of Options:** ${numberOfOptions}
+- **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.
@@ -639,7 +612,13 @@ ${exampleJson}
 
 Now, generate the JSON for the requested question.`;
 }
-async function generateMCQQuestion(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 GoogleGenAI({ apiKey });
   const model = "gemini-2.5-flash";
   const config = {
@@ -678,8 +657,15 @@ async function generateMCQQuestion(clientInput, apiKey) {
       }
       const parsedJson = JSON.parse(rawText);
       DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AIMCQOutputFieldsSchema.parse(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();
@@ -689,25 +675,29 @@ async function generateMCQQuestion(clientInput, apiKey) {
       }
       const finalOptions = [];
       const tempIdToFinalIdMap = {};
+      const allTempIds = /* @__PURE__ */ new Set();
       aiGeneratedContent.options.forEach((aiOption) => {
-        const finalId = generateUniqueId("opt_");
+        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 finalCorrectAnswerId = tempIdToFinalIdMap[aiGeneratedContent.correctTempOptionId];
-      if (!finalCorrectAnswerId) {
-        throw new Error(`Correct option ID '${aiGeneratedContent.correctTempOptionId}' is invalid`);
-      }
       const completeQuestion = {
-        id: generateUniqueId("mcq_ai_"),
-        questionType: "multiple_choice",
+        id: generateUniqueId("mrq_ai_"),
+        questionType: "multiple_response",
         prompt: aiGeneratedContent.prompt,
         options: finalOptions,
-        correctAnswerId: finalCorrectAnswerId,
+        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,
@@ -715,10 +705,10 @@ async function generateMCQQuestion(clientInput, apiKey) {
         category: clientInput.quizContext?.originalCategory,
         imageUrl: clientInput.imageUrl
       };
-      const validatedQuestion = MultipleChoiceQuestionZodSchema.parse(completeQuestion);
+      const validatedQuestion = MultipleResponseQuestionZodSchema.parse(completeQuestion);
       attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
       console.log(`
-\u2705 MCQ generation successful on attempt ${attempt} (${duration}ms)`);
+\u2705 MRQ generation successful on attempt ${attempt} (${duration}ms)`);
       if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
       return { question: validatedQuestion };
     } catch (error) {
@@ -734,102 +724,85 @@ async function generateMCQQuestion(clientInput, apiKey) {
     }
   }
   DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate MCQ question after ${MAX_RETRY_ATTEMPTS3} attempts. Last error: ${lastError?.message}`;
+  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 };
 }
 BaseQuestionGenerationClientInputSchema.extend({
-  numberOfOptions: z.number().int().min(2).max(8).optional().default(5),
-  minCorrectAnswers: z.number().int().min(1).optional().default(2),
-  maxCorrectAnswers: z.number().int().min(1).optional().default(3)
+  isCaseSensitive: z.boolean().optional().default(false)
 });
-var AIMRQOutputFieldsSchema = z.object({
-  prompt: z.string(),
-  options: z.array(z.object({ tempId: z.string(), text: z.string() })).min(2).max(8),
-  correctTempOptionIds: z.array(z.string()).min(1),
+var AIShortAnswerOutputFieldsSchema = z.object({
+  prompt: z.string().describe("The question text that prompts the user for a short answer."),
+  acceptedAnswers: z.array(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: z.string().optional(),
   points: z.number().optional().default(10),
   difficulty: z.enum(["easy", "medium", "hard"]).optional(),
   topic: z.string().optional(),
-  verifiedCategory: z.string().optional().describe("The category this question actually addresses.")
+  verifiedCategory: z.string().optional()
+  // Thêm để xác thực
 });
 
-// src/ai/flows/question-gen/generate-mrq-question.ts
+// 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, difficulty, numberOfOptions, minCorrectAnswers, maxCorrectAnswers, imageUrl } = clientInput;
+  const { quizContext, language, difficulty, 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.
+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 options must be directly related to the content of this image.` : "";
+  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} (This is the ONLY language to be used)`,
+    `**Required Category:** ${category}`,
     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}`
+    quizContext?.targetMisconception && `**Target Misconception:** The question should require an answer that corrects this specific misconception: "${quizContext.targetMisconception}"`
   ].filter(Boolean).map((s) => `- ${s}`).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.",
+    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: "medium",
-    topic: "Programming Paradigms",
+    difficulty: "easy",
+    topic: "Swift Constants",
     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.
+  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, 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.
+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 Multiple Response 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:** ${language}
 - **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.
+Your response must be ONLY the JSON object, matching this exact structure:
 
 ${exampleJson}
 
 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}).` };
-  }
+async function generateShortAnswerQuestion(clientInput, apiKey) {
   const ai = new GoogleGenAI({ apiKey });
   const model = "gemini-2.5-flash";
   const config = {
-    temperature: 0.8,
+    temperature: 0.5,
     responseMimeType: "application/json",
     thinkingConfig: {
       thinkingBudget: 4e3
@@ -850,29 +823,16 @@ async function generateMRQQuestion(clientInput, apiKey) {
         parts.unshift(imagePart);
       }
       const contents = [{ role: "user", parts }];
-      const aiResult = await ai.models.generateContent({
-        model,
-        config,
-        contents
-      });
+      const aiResult = await ai.models.generateContent({ model, config, 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 = AIMRQOutputFieldsSchema.parse(parsedJson);
+      const aiGeneratedContent = AIShortAnswerOutputFieldsSchema.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();
@@ -880,31 +840,16 @@ async function generateMRQQuestion(clientInput, apiKey) {
           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",
+        id: generateUniqueId("saq_ai_"),
+        questionType: "short_answer",
         prompt: aiGeneratedContent.prompt,
-        options: finalOptions,
-        correctAnswerIds: finalCorrectAnswerIds,
+        acceptedAnswers: aiGeneratedContent.acceptedAnswers,
+        isCaseSensitive: clientInput.isCaseSensitive,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
         topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
+        difficulty: clientInput.difficulty,
         contextCode: clientInput.quizContext?.plannedContextId,
         bloomLevel: clientInput.quizContext?.plannedBloomLevel,
         learningObjective: clientInput.quizContext?.originalLoId,
@@ -912,10 +857,10 @@ async function generateMRQQuestion(clientInput, apiKey) {
         category: clientInput.quizContext?.originalCategory,
         imageUrl: clientInput.imageUrl
       };
-      const validatedQuestion = MultipleResponseQuestionZodSchema.parse(completeQuestion);
+      const validatedQuestion = ShortAnswerQuestionZodSchema.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)`);
+\u2705 Short Answer generation successful on attempt ${attempt} (${duration}ms)`);
       if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
       return { question: validatedQuestion };
     } catch (error) {
@@ -931,7 +876,7 @@ async function generateMRQQuestion(clientInput, apiKey) {
     }
   }
   DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate MRQ question after ${MAX_RETRY_ATTEMPTS4} attempts. Last error: ${lastError?.message}`;
+  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 };
@@ -1116,6 +1061,192 @@ async function generateNumericQuestion(clientInput, apiKey) {
   console.error(errorMessage);
   return { error: errorMessage };
 }
+BaseQuestionGenerationClientInputSchema.extend({
+  numberOfBlanks: z.number().int().min(1).max(5).optional().default(1),
+  isCaseSensitive: z.boolean().optional().default(false)
+});
+var AIFillInTheBlanksOutputFieldsSchema = z.object({
+  prompt: 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: z.array(z.object({
+    type: z.enum(["text", "blank"]),
+    content: z.string().optional().describe("The text content for a 'text' segment."),
+    acceptedAnswers: z.array(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: z.string().optional(),
+  points: z.number().optional().default(10),
+  difficulty: z.enum(["easy", "medium", "hard"]).optional(),
+  topic: z.string().optional(),
+  verifiedCategory: 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, 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((s) => `- ${s}`).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:** ${language}
+- **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 GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config = {
+    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, 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((s) => s.type === "blank").length;
+      if (blankCount !== clientInput.numberOfBlanks) {
+        throw new Error(`AI generated ${blankCount} blanks, but ${clientInput.numberOfBlanks} were required.`);
+      }
+      aiGeneratedContent.segments.forEach((segment, index) => {
+        if (segment.type === "blank" && (!segment.acceptedAnswers || segment.acceptedAnswers.length === 0)) {
+          throw new Error(`Segment ${index} is a 'blank' but is missing 'acceptedAnswers'.`);
+        }
+        if (segment.type === "text" && typeof segment.content !== "string") {
+          throw new Error(`Segment ${index} 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));
+      }
+    }
+  }
+  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 };
+}
 BaseQuestionGenerationClientInputSchema.extend({
   numberOfItems: z.number().int().min(2).max(10).optional().default(4)
 });
@@ -1133,9 +1264,9 @@ var AISequenceOutputFieldsSchema = z.object({
 });
 
 // src/ai/flows/question-gen/generate-sequence-question.ts
-var MAX_RETRY_ATTEMPTS6 = 3;
-var RETRY_DELAY_MS6 = 3e3;
-function buildEnhancedPrompt6(clientInput, attemptNumber) {
+var MAX_RETRY_ATTEMPTS7 = 3;
+var RETRY_DELAY_MS7 = 3e3;
+function buildEnhancedPrompt7(clientInput, attemptNumber) {
   const { quizContext, language, difficulty, numberOfItems, imageUrl } = clientInput;
   const category = quizContext?.originalCategory || "the specified technical category";
   const attemptInfo = attemptNumber > 1 ? `
@@ -1204,9 +1335,9 @@ async function generateSequenceQuestion(clientInput, apiKey) {
   };
   const attemptResults = [];
   let lastError = null;
-  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS6; attempt++) {
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS7; attempt++) {
     const startTime = Date.now();
-    const promptText = buildEnhancedPrompt6(clientInput, attempt);
+    const promptText = buildEnhancedPrompt7(clientInput, attempt);
     const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
     try {
       DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
@@ -1271,27 +1402,30 @@ async function generateSequenceQuestion(clientInput, apiKey) {
       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;
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS7;
       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));
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS7}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS7));
       }
     }
   }
   DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate Sequence question after ${MAX_RETRY_ATTEMPTS6} attempts. Last error: ${lastError?.message}`;
+  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 };
 }
 BaseQuestionGenerationClientInputSchema.extend({
-  isCaseSensitive: z.boolean().optional().default(false)
+  numberOfPairs: z.number().int().min(2).max(8).optional().default(4),
+  shuffleOptions: z.boolean().optional().default(true)
 });
-var AIShortAnswerOutputFieldsSchema = z.object({
-  prompt: z.string().describe("The question text that prompts the user for a short answer."),
-  acceptedAnswers: z.array(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
+var AIMatchingOutputFieldsSchema = z.object({
+  prompt: z.string().describe("The instructional text for the user, e.g., 'Match the concept to its definition.'"),
+  correctPairs: z.array(z.object({
+    promptText: z.string().min(1).describe("The text for the left-hand side item (the prompt)."),
+    optionText: z.string().min(1).describe("The text for the right-hand side item (the matching option).")
+  })).min(2),
   explanation: z.string().optional(),
   points: z.number().optional().default(10),
   difficulty: z.enum(["easy", "medium", "hard"]).optional(),
@@ -1300,52 +1434,57 @@ var AIShortAnswerOutputFieldsSchema = z.object({
   // Thêm để xác thực
 });
 
-// src/ai/flows/question-gen/generate-short-answer-question.ts
-var MAX_RETRY_ATTEMPTS7 = 3;
-var RETRY_DELAY_MS7 = 3e3;
-function buildEnhancedPrompt7(clientInput, attemptNumber) {
-  const { quizContext, language, difficulty, imageUrl } = clientInput;
+// 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, 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. Ensure 'acceptedAnswers' is a non-empty array of strings and the JSON is valid.
+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 question and its short answer must be directly related to the content of this image.` : "";
+  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:** The question should require an answer that corrects this specific misconception: "${quizContext.targetMisconception}"`
+    quizContext?.targetMisconception && `**Target Misconception:** Design a pair that specifically tests this confusion: "${quizContext.targetMisconception}"`
   ].filter(Boolean).map((s) => `- ${s}`).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.",
+    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 Constants",
+    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 Short Answer Question.
+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.  **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.
+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 Short Answer 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:** ${language}
 - **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:
@@ -1354,11 +1493,11 @@ ${exampleJson}
 
 Now, generate the JSON for the requested question.`;
 }
-async function generateShortAnswerQuestion(clientInput, apiKey) {
+async function generateMatchingQuestion(clientInput, apiKey) {
   const ai = new GoogleGenAI({ apiKey });
   const model = "gemini-2.5-flash";
   const config = {
-    temperature: 0.5,
+    temperature: 0.8,
     responseMimeType: "application/json",
     thinkingConfig: {
       thinkingBudget: 4e3
@@ -1366,9 +1505,9 @@ async function generateShortAnswerQuestion(clientInput, apiKey) {
   };
   const attemptResults = [];
   let lastError = null;
-  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS7; attempt++) {
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS8; attempt++) {
     const startTime = Date.now();
-    const promptText = buildEnhancedPrompt7(clientInput, attempt);
+    const promptText = buildEnhancedPrompt8(clientInput, attempt);
     const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
     try {
       DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
@@ -1387,8 +1526,11 @@ async function generateShortAnswerQuestion(clientInput, apiKey) {
       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);
+      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.`);
+      }
       if (clientInput.quizContext?.originalCategory) {
         const verifiedCategory = aiGeneratedContent.verifiedCategory?.toLowerCase();
         const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
@@ -1396,12 +1538,24 @@ async function generateShortAnswerQuestion(clientInput, apiKey) {
           throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
         }
       }
+      const finalPrompts = [];
+      const finalOptions = [];
+      const finalCorrectAnswerMap = [];
+      aiGeneratedContent.correctPairs.forEach((pair) => {
+        const promptId = generateUniqueId("m_p_");
+        const optionId = generateUniqueId("m_o_");
+        finalPrompts.push({ id: promptId, content: pair.promptText });
+        finalOptions.push({ id: optionId, content: pair.optionText });
+        finalCorrectAnswerMap.push({ promptId, optionId });
+      });
       const completeQuestion = {
-        id: generateUniqueId("saq_ai_"),
-        questionType: "short_answer",
+        id: generateUniqueId("match_ai_"),
+        questionType: "matching",
         prompt: aiGeneratedContent.prompt,
-        acceptedAnswers: aiGeneratedContent.acceptedAnswers,
-        isCaseSensitive: clientInput.isCaseSensitive,
+        prompts: finalPrompts,
+        options: finalOptions,
+        correctAnswerMap: finalCorrectAnswerMap,
+        shuffleOptions: clientInput.shuffleOptions,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
         topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
@@ -1413,90 +1567,95 @@ async function generateShortAnswerQuestion(clientInput, apiKey) {
         category: clientInput.quizContext?.originalCategory,
         imageUrl: clientInput.imageUrl
       };
-      const validatedQuestion = ShortAnswerQuestionZodSchema.parse(completeQuestion);
+      const validatedQuestion = MatchingQuestionZodSchema.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)`);
+\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_ATTEMPTS7;
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS8;
       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));
+        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 Short Answer question after ${MAX_RETRY_ATTEMPTS7} attempts. Last error: ${lastError?.message}`;
+  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 };
 }
-BaseQuestionGenerationClientInputSchema.extend({});
-var AITrueFalseOutputFieldsSchema = z.object({
-  prompt: z.string().describe("The statement that the user will evaluate as true or false."),
-  correctAnswer: z.boolean(),
-  explanation: z.string().optional().describe("An explanation of why the statement is true or false, especially important if false."),
-  points: z.number().optional().default(10),
-  difficulty: z.enum(["easy", "medium", "hard"]).optional(),
-  topic: z.string().optional(),
-  verifiedCategory: z.string().optional()
-  // Thêm để xác thực
+BaseQuestionGenerationClientInputSchema.extend({
+  codingLanguage: z.enum(["cpp", "javascript", "python", "swift", "csharp"])
+});
+var AICodingQuestionOutputSchema = z.object({
+  prompt: z.string().describe("The problem description for the user."),
+  functionSignature: z.string().optional().describe("A suggested function signature for the user to implement."),
+  solutionCode: z.string().describe("A complete, correct model solution in the specified language."),
+  testCases: z.array(z.object({
+    input: z.array(z.any()),
+    // FIX: Use .refine to make it explicitly non-optional for TypeScript's inference
+    expectedOutput: z.any().refine((val) => val !== void 0, {
+      message: "expectedOutput is required and cannot be undefined."
+    }),
+    isPublic: z.boolean()
+  })).min(3, { message: "Must provide at least 3 test cases." }),
+  verifiedCodingLanguage: z.enum(["cpp", "javascript", "python", "swift", "csharp"]).optional().describe("The programming language this question actually addresses.")
 });
 
-// src/ai/flows/question-gen/generate-true-false-question.ts
-var MAX_RETRY_ATTEMPTS8 = 3;
-var RETRY_DELAY_MS8 = 3e3;
-function buildEnhancedPrompt8(clientInput, attemptNumber) {
-  const { quizContext, language, difficulty, imageUrl } = clientInput;
-  const category = quizContext?.originalCategory || "the specified technical category";
+// src/ai/flows/question-gen/generate-coding-question.ts
+var MAX_RETRY_ATTEMPTS9 = 3;
+var RETRY_DELAY_MS9 = 3e3;
+function buildEnhancedPrompt9(clientInput, attemptNumber) {
+  const { quizContext, difficulty, codingLanguage, language, imageUrl } = clientInput;
+  const subject = quizContext?.originalSubject || codingLanguage;
   const attemptInfo = attemptNumber > 1 ? `
 ## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed. Ensure the JSON is valid and 'correctAnswer' is a boolean.
+Previous attempts failed. Pay strict attention to the JSON schema and all rules. Ensure every object in the 'testCases' array has a non-null 'expectedOutput' field.
 
 ` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The True/False statement must be directly related to the content of this image.` : "";
-  const misconceptionGuidance = quizContext?.targetMisconception ? `**Target Misconception:** The statement you create MUST be FALSE and based on this common mistake: "${quizContext.targetMisconception}"` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The coding problem must be directly related to processing or interpreting the content of this image.` : "";
   const contextStrings = [
-    `**Required Category:** ${category}`,
+    `**Subject:** ${subject}`,
     quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
     imageContextInstruction,
     quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    misconceptionGuidance,
-    quizContext?.difficultyReason && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
+    quizContext?.targetMisconception && `**Target Misconception:** The problem should test against this common error: "${quizContext.targetMisconception}"`
   ].filter(Boolean).map((s) => `- ${s}`).join("\n");
   const exampleJson = JSON.stringify({
-    prompt: "In Swift, you must explicitly unwrap an Optional value before you can use its stored value.",
-    correctAnswer: true,
-    explanation: "Optional values in Swift represent the presence or absence of a value. To access the value when it exists, you must unwrap it using methods like 'if let', 'guard let', or the force unwrap operator '!'.",
-    points: 10,
-    difficulty: "easy",
-    topic: "Swift Optionals",
-    verifiedCategory: category
+    prompt: "Write a function named 'add' that takes two integers and returns their sum.",
+    functionSignature: "function add(a, b) { ... }",
+    solutionCode: "function add(a, b) {\n  return a + b;\n}",
+    testCases: [
+      { "input": [1, 2], "expectedOutput": 3, "isPublic": true },
+      { "input": [-1, 1], "expectedOutput": 0, "isPublic": true },
+      { "input": [0, 0], "expectedOutput": 0, "isPublic": false }
+    ],
+    verifiedCodingLanguage: "javascript"
   }, 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 True/False Question.
+  return `${attemptInfo}You are an expert programming problem designer for ${subject}.
+Generate a single, high-quality Coding question.
 
-## Core Rules (Non-negotiable)
-1.  **Category Purity:** The statement ('prompt') MUST be exclusively about **${category}**.
-2.  **Clarity:** The statement must be definitively true or false, with no ambiguity.
-3.  **Misconception Priority:** If a Target Misconception is provided, the statement MUST be FALSE and reflect that misconception. This is a critical rule.
-4.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object.
+## Core Rules
+1.  **Language Purity:** All code ('functionSignature', 'solutionCode') MUST be in **${codingLanguage}**.
+2.  **Context Adherence:** The problem MUST be directly related to the provided context.
+3.  **Format Integrity:** You MUST return ONLY a single, valid JSON object.
+4.  **Test Case Integrity:** Every test case object in the 'testCases' array MUST have a non-null and defined 'expectedOutput' field. This is a critical rule.
 
 ## CRITICAL CONTEXT FOR THIS QUESTION
 ${contextStrings}
 
 ## Task: Generate the Question
-Based on all the rules and context above, generate a single True/False Question.
-
 ### Input Parameters
 - **Topic for Question:** ${quizContext?.plannedTopic || "General"}
-- **Language for Text:** ${language}
+- **Natural Language for Text:** ${language}
+- **Coding Language:** ${codingLanguage}
 - **Difficulty Level:** ${difficulty}
 
 ### Required JSON Output Format
@@ -1506,21 +1665,21 @@ ${exampleJson}
 
 Now, generate the JSON for the requested question.`;
 }
-async function generateTrueFalseQuestion(clientInput, apiKey) {
+async function generateCodingQuestion(clientInput, apiKey) {
   const ai = new GoogleGenAI({ apiKey });
   const model = "gemini-2.5-flash";
   const config = {
-    temperature: 0.6,
+    temperature: 0.5,
     responseMimeType: "application/json",
     thinkingConfig: {
-      thinkingBudget: 4e3
+      thinkingBudget: 5e3
     }
   };
   const attemptResults = [];
   let lastError = null;
-  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS8; attempt++) {
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS9; attempt++) {
     const startTime = Date.now();
-    const promptText = buildEnhancedPrompt8(clientInput, attempt);
+    const promptText = buildEnhancedPrompt9(clientInput, attempt);
     const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
     try {
       DebugLogger.logPrompt(attempt, promptText, { ...clientInput, attemptNumber: attempt, promptHash });
@@ -1539,26 +1698,27 @@ async function generateTrueFalseQuestion(clientInput, apiKey) {
       if (!rawText) throw new Error("AI returned an empty response.");
       const parsedJson = JSON.parse(rawText);
       DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
-      const aiGeneratedContent = AITrueFalseOutputFieldsSchema.parse(parsedJson);
+      const aiGeneratedContent = AICodingQuestionOutputSchema.parse(parsedJson);
       DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      if (clientInput.quizContext?.targetMisconception && aiGeneratedContent.correctAnswer === true) {
-        throw new Error("AI failed to follow the Misconception Priority rule. The answer should have been false.");
-      }
-      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}`);
-        }
+      if (aiGeneratedContent.verifiedCodingLanguage && aiGeneratedContent.verifiedCodingLanguage !== clientInput.codingLanguage) {
+        throw new Error(`Language mismatch: Required ${clientInput.codingLanguage}, but AI generated for ${aiGeneratedContent.verifiedCodingLanguage}.`);
       }
+      const testCases = aiGeneratedContent.testCases.map((tc) => ({
+        id: generateUniqueId("tc_"),
+        input: tc.input,
+        expectedOutput: tc.expectedOutput,
+        isPublic: tc.isPublic
+      }));
       const completeQuestion = {
-        id: generateUniqueId("tf_ai_"),
-        questionType: "true_false",
+        id: generateUniqueId("coding_"),
+        questionType: "coding",
         prompt: aiGeneratedContent.prompt,
-        correctAnswer: aiGeneratedContent.correctAnswer,
-        explanation: aiGeneratedContent.explanation,
-        points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.quizContext?.originalTopic,
+        codingLanguage: clientInput.codingLanguage,
+        functionSignature: aiGeneratedContent.functionSignature,
+        solutionCode: aiGeneratedContent.solutionCode,
+        testCases,
+        points: 25,
+        topic: clientInput.quizContext?.originalTopic,
         difficulty: clientInput.difficulty,
         contextCode: clientInput.quizContext?.plannedContextId,
         bloomLevel: clientInput.quizContext?.plannedBloomLevel,
@@ -1567,26 +1727,26 @@ async function generateTrueFalseQuestion(clientInput, apiKey) {
         category: clientInput.quizContext?.originalCategory,
         imageUrl: clientInput.imageUrl
       };
-      const validatedQuestion = TrueFalseQuestionZodSchema.parse(completeQuestion);
+      CodingQuestionZodSchema.parse(completeQuestion);
       attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
       console.log(`
-\u2705 True/False generation successful on attempt ${attempt} (${duration}ms)`);
+\u2705 Coding question generation successful on attempt ${attempt} (${duration}ms)`);
       if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
-      return { question: validatedQuestion };
+      return { question: completeQuestion };
     } 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;
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS9;
       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));
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS9}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS9));
       }
     }
   }
   DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate True/False question after ${MAX_RETRY_ATTEMPTS8} attempts. Last error: ${lastError?.message}`;
+  const errorMessage = `Failed to generate Coding question after ${MAX_RETRY_ATTEMPTS9} attempts. Last error: ${lastError?.message}`;
   console.error("\n\u274C Final Result: FAILED");
   console.error(errorMessage);
   return { error: errorMessage };
@@ -2494,166 +2654,6 @@ TopicDataService.EXPECTED_HEADERS = [
   "STEM Element(s)",
   "Bloom\u2019s Level(s) Guideline"
 ];
-BaseQuestionGenerationClientInputSchema.extend({
-  codingLanguage: z.enum(["cpp", "javascript", "python", "swift", "csharp"])
-});
-var AICodingQuestionOutputSchema = z.object({
-  prompt: z.string().describe("The problem description for the user."),
-  functionSignature: z.string().optional().describe("A suggested function signature for the user to implement."),
-  solutionCode: z.string().describe("A complete, correct model solution in the specified language."),
-  testCases: z.array(z.object({
-    input: z.array(z.any()),
-    // FIX: Use .refine to make it explicitly non-optional for TypeScript's inference
-    expectedOutput: z.any().refine((val) => val !== void 0, {
-      message: "expectedOutput is required and cannot be undefined."
-    }),
-    isPublic: z.boolean()
-  })).min(3, { message: "Must provide at least 3 test cases." }),
-  verifiedCodingLanguage: z.enum(["cpp", "javascript", "python", "swift", "csharp"]).optional().describe("The programming language this question actually addresses.")
-});
-
-// src/ai/flows/question-gen/generate-coding-question.ts
-var MAX_RETRY_ATTEMPTS9 = 3;
-var RETRY_DELAY_MS9 = 3e3;
-function buildEnhancedPrompt9(clientInput, attemptNumber) {
-  const { quizContext, difficulty, codingLanguage, language, imageUrl } = clientInput;
-  const subject = quizContext?.originalSubject || codingLanguage;
-  const attemptInfo = attemptNumber > 1 ? `
-## DEBUG INFO - This is attempt #${attemptNumber}
-Previous attempts failed. Pay strict attention to the JSON schema and all rules. Ensure every object in the 'testCases' array has a non-null 'expectedOutput' field.
-
-` : "";
-  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The coding problem must be directly related to processing or interpreting the content of this image.` : "";
-  const contextStrings = [
-    `**Subject:** ${subject}`,
-    quizContext?.loDescription && `**Learning Objective:** ${quizContext.loDescription}`,
-    imageContextInstruction,
-    quizContext?.plannedBloomLevel && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
-    quizContext?.targetMisconception && `**Target Misconception:** The problem should test against this common error: "${quizContext.targetMisconception}"`
-  ].filter(Boolean).map((s) => `- ${s}`).join("\n");
-  const exampleJson = JSON.stringify({
-    prompt: "Write a function named 'add' that takes two integers and returns their sum.",
-    functionSignature: "function add(a, b) { ... }",
-    solutionCode: "function add(a, b) {\n  return a + b;\n}",
-    testCases: [
-      { "input": [1, 2], "expectedOutput": 3, "isPublic": true },
-      { "input": [-1, 1], "expectedOutput": 0, "isPublic": true },
-      { "input": [0, 0], "expectedOutput": 0, "isPublic": false }
-    ],
-    verifiedCodingLanguage: "javascript"
-  }, null, 2);
-  return `${attemptInfo}You are an expert programming problem designer for ${subject}.
-Generate a single, high-quality Coding question.
-
-## Core Rules
-1.  **Language Purity:** All code ('functionSignature', 'solutionCode') MUST be in **${codingLanguage}**.
-2.  **Context Adherence:** The problem MUST be directly related to the provided context.
-3.  **Format Integrity:** You MUST return ONLY a single, valid JSON object.
-4.  **Test Case Integrity:** Every test case object in the 'testCases' array MUST have a non-null and defined 'expectedOutput' field. This is a critical rule.
-
-## CRITICAL CONTEXT FOR THIS QUESTION
-${contextStrings}
-
-## Task: Generate the Question
-### Input Parameters
-- **Topic for Question:** ${quizContext?.plannedTopic || "General"}
-- **Natural Language for Text:** ${language}
-- **Coding Language:** ${codingLanguage}
-- **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 generateCodingQuestion(clientInput, apiKey) {
-  const ai = new GoogleGenAI({ apiKey });
-  const model = "gemini-2.5-flash";
-  const config = {
-    temperature: 0.5,
-    responseMimeType: "application/json",
-    thinkingConfig: {
-      thinkingBudget: 5e3
-    }
-  };
-  const attemptResults = [];
-  let lastError = null;
-  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS9; attempt++) {
-    const startTime = Date.now();
-    const promptText = buildEnhancedPrompt9(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, 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 = AICodingQuestionOutputSchema.parse(parsedJson);
-      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
-      if (aiGeneratedContent.verifiedCodingLanguage && aiGeneratedContent.verifiedCodingLanguage !== clientInput.codingLanguage) {
-        throw new Error(`Language mismatch: Required ${clientInput.codingLanguage}, but AI generated for ${aiGeneratedContent.verifiedCodingLanguage}.`);
-      }
-      const testCases = aiGeneratedContent.testCases.map((tc) => ({
-        id: generateUniqueId("tc_"),
-        input: tc.input,
-        expectedOutput: tc.expectedOutput,
-        isPublic: tc.isPublic
-      }));
-      const completeQuestion = {
-        id: generateUniqueId("coding_"),
-        questionType: "coding",
-        prompt: aiGeneratedContent.prompt,
-        codingLanguage: clientInput.codingLanguage,
-        functionSignature: aiGeneratedContent.functionSignature,
-        solutionCode: aiGeneratedContent.solutionCode,
-        testCases,
-        points: 25,
-        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
-      };
-      CodingQuestionZodSchema.parse(completeQuestion);
-      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
-      console.log(`
-\u2705 Coding question generation successful on attempt ${attempt} (${duration}ms)`);
-      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
-      return { question: completeQuestion };
-    } 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_ATTEMPTS9;
-      DebugLogger.logRetryInfo(attempt, error, willRetry);
-      if (willRetry) {
-        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS9}ms...`);
-        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS9));
-      }
-    }
-  }
-  DebugLogger.logAttemptSummary(attemptResults);
-  const errorMessage = `Failed to generate Coding question after ${MAX_RETRY_ATTEMPTS9} 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
 var MAX_ATTEMPTS = 3;
@@ -3525,4 +3525,4 @@ Now, generate the JSON response.`;
   }
 }
 
-export { assessAndMapDocument, generateFillInTheBlanksQuestion, generateLearningAnalysis, generateMCQQuestion, generateMRQQuestion, generateMatchingQuestion, generateMotivationalQuote, generateNumericQuestion, generatePracticeSuggestion, generateQuestionsFromQuizPlan, generateQuizFromText, generateQuizPlan, generateQuizReview, generateSequenceQuestion, generateShortAnswerQuestion, generateSingleKnowledgeCard, generateTrueFalseQuestion, planKnowledgeCards };
+export { assessAndMapDocument, generateCodingQuestion, generateFillInTheBlanksQuestion, generateLearningAnalysis, generateMCQQuestion, generateMRQQuestion, generateMatchingQuestion, generateMotivationalQuote, generateNumericQuestion, generatePracticeSuggestion, generateQuestionsFromQuizPlan, generateQuizFromText, generateQuizPlan, generateQuizReview, generateSequenceQuestion, generateShortAnswerQuestion, generateSingleKnowledgeCard, generateTrueFalseQuestion, planKnowledgeCards };