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

package/dist/ai.js

@@ -1,3 +1,4 @@
+import { GoogleGenAI } from '@google/genai';
 import { z } from 'zod';
 import { genkit } from 'genkit';
 import { gemini20Flash, googleAI } from '@genkit-ai/googleai';
@@ -21,282 +22,520 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 
 // src/utils/idGenerators.ts
 function generateUniqueId(prefix = "id_") {
   return prefix + Date.now().toString(36) + Math.random().toString(36).substring(2, 7);
 }
+var DebugLogger = class {
+  static formatTimestamp() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  static logPrompt(attempt, prompt, inputContext) {
+    console.log("\n" + "=".repeat(80));
+    console.log(`[${this.formatTimestamp()}] \u{1F50D} PROMPT DEBUG - Attempt ${attempt}`);
+    console.log("=".repeat(80));
+    console.log("Input Context:", JSON.stringify(inputContext, null, 2));
+    console.log("\n" + "-".repeat(40) + " FULL PROMPT " + "-".repeat(40));
+    console.log(prompt);
+    console.log("-".repeat(90));
+    console.log("Prompt Length:", prompt.length, "characters");
+    console.log("=".repeat(80) + "\n");
+  }
+  static logResponse(attempt, rawResponse) {
+    console.log("\n" + "=".repeat(80));
+    console.log(`[${this.formatTimestamp()}] \u{1F4DD} AI RESPONSE - Attempt ${attempt}`);
+    console.log("=".repeat(80));
+    console.log("Raw Response Length:", rawResponse.length, "characters");
+    console.log("\n" + "-".repeat(40) + " FULL RESPONSE " + "-".repeat(39));
+    console.log(rawResponse);
+    console.log("-".repeat(90));
+    console.log("=".repeat(80) + "\n");
+  }
+  static logValidation(attempt, step, data) {
+    console.log(`[${this.formatTimestamp()}] \u2705 VALIDATION - Attempt ${attempt} - ${step}`);
+    console.log(JSON.stringify(data, null, 2));
+    console.log("-".repeat(50));
+  }
+  static logRetryInfo(attempt, error, willRetry) {
+    console.log("\n" + "=".repeat(80));
+    console.log(`[${this.formatTimestamp()}] \u26A0\uFE0F  RETRY INFO - Attempt ${attempt}`);
+    console.log("=".repeat(80));
+    console.log("Error Type:", error.constructor.name);
+    console.log("Error Message:", error.message);
+    console.log("Will Retry:", willRetry);
+    if (error.stack) {
+      console.log("Stack Trace:", error.stack);
+    }
+    console.log("=".repeat(80) + "\n");
+  }
+  static logAttemptSummary(attemptResults) {
+    console.log("\n" + "=".repeat(80));
+    console.log(`[${this.formatTimestamp()}] \u{1F4CA} ATTEMPT SUMMARY`);
+    console.log("=".repeat(80));
+    attemptResults.forEach((result, index) => {
+      console.log(`Attempt ${index + 1}:`);
+      console.log(`  Status: ${result.success ? "\u2705 SUCCESS" : "\u274C FAILED"}`);
+      console.log(`  Duration: ${result.duration}ms`);
+      console.log(`  Error: ${result.error || "None"}`);
+      console.log(`  Prompt Length: ${result.promptLength} chars`);
+      console.log(`  Response Length: ${result.responseLength || 0} chars`);
+      console.log("");
+    });
+    console.log("=".repeat(80) + "\n");
+  }
+};
 
-// src/ai/flows/generate-fitb-question.ts
-function extractJsonFromMarkdown(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
+// src/utils/aiUtils.ts
+async function urlToGenerativePart(url, mimeType) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch image from URL: ${url}. Status: ${response.status} ${response.statusText}`);
+  }
+  const buffer = await response.arrayBuffer();
+  return {
+    inlineData: {
+      data: Buffer.from(buffer).toString("base64"),
+      mimeType
+    }
+  };
 }
-z.object({
-  topic: z.string().describe("The topic for the question."),
-  language: z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfBlanks: z.number().int().min(1).max(5).optional().default(1).describe("Number of blanks to include (1-5)."),
-  isCaseSensitive: z.boolean().optional().default(false).describe("Whether answers should be case-sensitive."),
-  contextDescription: z.string().optional().describe("A specific context or scenario for the question."),
-  selectedContextId: z.string().optional().describe("The ID of the selected context.")
+var QuizContextSchema = z.object({
+  plannedTopic: z.string().optional(),
+  plannedQuestionType: z.string().optional(),
+  plannedBloomLevel: z.string().optional(),
+  plannedContextId: z.string().optional(),
+  targetMisconception: z.string().optional(),
+  difficultyReason: z.string().optional(),
+  topicSpecificity: z.enum(["broad", "focused", "specific"]).optional(),
+  originalLoId: z.string().optional(),
+  originalSubject: z.string().optional(),
+  originalCategory: z.string().optional(),
+  originalTopic: z.string().optional(),
+  loDescription: z.string().optional().describe("The full description of the learning objective for deep context.")
 });
-z.object({
-  prompt: z.string().describe("The overall instruction for the question."),
-  sentenceWithPlaceholders: z.string().describe("The sentence containing placeholders like {{placeholder_name}}."),
-  blanks: z.array(
-    z.object({
-      placeholder: z.string().describe("The placeholder name (without curly braces)."),
-      acceptedAnswers: z.array(z.string().min(1)).min(1).describe("Array of acceptable answers.")
-    })
-  ).min(1),
-  isCaseSensitive: z.boolean().optional(),
+var BaseQuestionGenerationClientInputSchema = z.object({
+  language: z.string().optional().default("English"),
+  difficulty: z.enum(["easy", "medium", "hard"]),
+  quizContext: QuizContextSchema.optional(),
+  imageUrl: z.string().url().optional().describe("Optional URL of an image to be used as context.")
+});
+var BaseQuestionZodSchema = z.object({
+  id: z.string(),
+  prompt: z.string().min(1),
+  points: z.number().min(0).optional(),
   explanation: z.string().optional(),
-  points: z.number().optional().default(10),
   difficulty: z.enum(["easy", "medium", "hard"]).optional(),
-  topic: z.string().optional()
+  topic: z.string().optional(),
+  category: z.string().optional(),
+  subject: z.string().optional(),
+  learningObjective: z.string().optional(),
+  bloomLevel: z.string().optional(),
+  contextCode: z.string().optional(),
+  gradeBand: z.string().optional(),
+  course: z.string().optional(),
+  glossary: z.array(z.string()).optional()
 });
-var FillInTheBlanksQuestionZodSchema = z.object({
-  id: z.string(),
+var TrueFalseQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: z.literal("true_false"),
+  correctAnswer: z.boolean()
+});
+var MultipleChoiceQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: z.literal("multiple_choice"),
+  options: z.array(z.object({ id: z.string(), text: z.string().min(1) })).min(2),
+  correctAnswerId: z.string()
+}).refine((data) => data.options.some((option) => option.id === data.correctAnswerId), {
+  message: "correctAnswerId must match one of the option IDs",
+  path: ["correctAnswerId"]
+});
+var MultipleResponseQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: z.literal("multiple_response"),
+  options: z.array(z.object({ id: z.string(), text: z.string().min(1) })).min(2),
+  correctAnswerIds: z.array(z.string()).min(1)
+}).refine((data) => data.correctAnswerIds.every((id) => data.options.some((opt) => opt.id === id)), {
+  message: "All correctAnswerIds must exist in the options array",
+  path: ["correctAnswerIds"]
+});
+var ShortAnswerQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: z.literal("short_answer"),
+  acceptedAnswers: z.array(z.string().min(1)).min(1),
+  isCaseSensitive: z.boolean().optional()
+});
+var NumericQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: z.literal("numeric"),
+  answer: z.number(),
+  tolerance: z.number().min(0).optional()
+});
+var FillInTheBlanksQuestionZodSchema = BaseQuestionZodSchema.extend({
   questionType: z.literal("fill_in_the_blanks"),
-  prompt: z.string().min(1),
   segments: z.array(z.object({
     type: z.enum(["text", "blank"]),
     content: z.string().optional(),
-    // Only for 'text' type
     id: z.string().optional()
-    // Only for 'blank' type
   })).min(1),
   answers: z.array(z.object({
     blankId: z.string(),
     acceptedValues: z.array(z.string().min(1)).min(1)
   })).min(1),
-  isCaseSensitive: z.boolean().optional(),
-  points: z.number().min(0).optional(),
-  explanation: z.string().optional()
-  // ... other fields
+  isCaseSensitive: z.boolean().optional()
 }).refine((data) => {
-  const segmentBlankIds = new Set(data.segments.filter((s) => s.type === "blank").map((s) => s.id));
+  const segmentBlankIds = new Set(data.segments.filter((s) => s.type === "blank" && s.id).map((s) => s.id));
   const answerBlankIds = new Set(data.answers.map((a) => a.blankId));
-  if (segmentBlankIds.size !== answerBlankIds.size) return false;
-  for (const id of segmentBlankIds) {
-    if (!answerBlankIds.has(id || "")) return false;
-  }
-  return true;
-}, {
-  message: "There must be a 1-to-1 correspondence between blank segments and answer definitions.",
-  path: ["answers"]
+  return segmentBlankIds.size === answerBlankIds.size && [...segmentBlankIds].every((id) => answerBlankIds.has(id));
+}, { message: "Mismatch between defined blanks in segments and their answers.", path: ["answers"] });
+var SequenceQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: z.literal("sequence"),
+  items: z.array(z.object({ id: z.string(), content: z.string().min(1) })).min(2),
+  correctOrder: z.array(z.string()).min(2)
+}).refine((data) => new Set(data.correctOrder).size === data.items.length, {
+  message: "correctOrder must contain all unique item IDs exactly once.",
+  path: ["correctOrder"]
 });
-z.object({
-  question: FillInTheBlanksQuestionZodSchema.optional().describe("The generated question.")
+var MatchingQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: z.literal("matching"),
+  prompts: z.array(z.object({ id: z.string(), content: z.string().min(1) })).min(2),
+  options: z.array(z.object({ id: z.string(), content: z.string().min(1) })).min(2),
+  correctAnswerMap: z.array(z.object({ promptId: z.string(), optionId: z.string() })).min(2),
+  shuffleOptions: z.boolean().optional()
+}).refine((data) => data.prompts.length === data.correctAnswerMap.length, {
+  message: "Each prompt must have exactly one corresponding answer in the map.",
+  path: ["correctAnswerMap"]
+});
+var CodingQuestionZodSchema = BaseQuestionZodSchema.extend({
+  questionType: z.literal("coding"),
+  codingLanguage: z.enum(["cpp", "javascript", "python", "swift", "csharp"]),
+  functionSignature: z.string().optional(),
+  solutionCode: z.string(),
+  testCases: z.array(z.object({
+    id: z.string(),
+    input: z.array(z.any()),
+    expectedOutput: z.any(),
+    isPublic: z.boolean()
+  })).min(1)
 });
-async function generateFillInTheBlanksQuestion(clientInput, apiKey) {
-  var _a;
-  try {
-    const ai = genkit({
-      plugins: [googleAI({ apiKey })],
-      model: gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer.
-Generate a single Fill-In-The-Blanks question in ${clientInput.language} with approximately ${clientInput.numberOfBlanks} blank(s).
 
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "Complete the famous saying.",
-  "sentenceWithPlaceholders": "Roses are {{color1}}, violets are {{color2}}.",
-  "blanks": [
-    { "placeholder": "color1", "acceptedAnswers": ["red"] },
-    { "placeholder": "color2", "acceptedAnswers": ["blue"] }
-  ],
-  "isCaseSensitive": false,
-  "explanation": "This is a classic nursery rhyme.",
-  "points": 10,
-  "difficulty": "easy",
-  "topic": "Nursery Rhymes"
-}
+// 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(),
+  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
+});
 
-Requirements:
-- Use double curly braces for placeholders, like {{placeholder_name}}.
-- Each placeholder name inside the braces must be unique.
-- The 'blanks' array must define the accepted answers for every unique placeholder in the sentence.
-- The 'placeholder' value in the 'blanks' array should NOT include the curly braces.
-- The content of 'prompt', 'sentenceWithPlaceholders', 'blanks.acceptedAnswers', 'explanation', and 'topic' must be in ${clientInput.language}.
+// src/ai/flows/question-gen/generate-fitb-question.ts
+var MAX_RETRY_ATTEMPTS = 3;
+var RETRY_DELAY_MS = 3e3;
+function buildEnhancedPrompt(clientInput, attemptNumber) {
+  const { quizContext, language, difficulty, numberOfBlanks, imageUrl } = clientInput;
+  const category = (quizContext == null ? void 0 : 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'.
 
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-Difficulty: ${clientInput.difficulty}
-Target Number of Blanks: ${clientInput.numberOfBlanks}
-Case Sensitive: ${clientInput.isCaseSensitive}
+` : "";
+  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 == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : 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.
 
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown(rawText);
-    console.log("AI Response:", jsonText);
-    const aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent) {
-      const segments = [];
-      const answers = [];
-      const placeholderToBlankIdMap = {};
-      aiGeneratedContent.blanks.forEach((blankInfo) => {
-        const blankId = generateUniqueId("blank_");
-        placeholderToBlankIdMap[blankInfo.placeholder] = blankId;
-        answers.push({
-          blankId,
-          acceptedValues: blankInfo.acceptedAnswers
-        });
-      });
-      const placeholderRegex = /\{\{([^}]+)\}\}/g;
-      let lastIndex = 0;
-      let match;
-      while ((match = placeholderRegex.exec(aiGeneratedContent.sentenceWithPlaceholders)) !== null) {
-        const placeholderName = match[1];
-        const blankId = placeholderToBlankIdMap[placeholderName];
-        if (match.index > lastIndex) {
-          segments.push({ type: "text", content: aiGeneratedContent.sentenceWithPlaceholders.substring(lastIndex, match.index) });
+## 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 == null ? void 0 : 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) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  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_ATTEMPTS; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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 = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.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 (blankId) {
-          segments.push({ type: "blank", id: blankId });
-        } else {
-          console.warn(`Placeholder {{${placeholderName}}} found in sentence but not defined in blanks array. Treating as literal text.`);
-          segments.push({ type: "text", content: match[0] });
+        if (segment.type === "text" && typeof segment.content !== "string") {
+          throw new Error(`Segment ${index} is 'text' but is missing 'content'.`);
+        }
+      });
+      if ((_f = clientInput.quizContext) == null ? void 0 : _f.originalCategory) {
+        const verifiedCategory = (_g = aiGeneratedContent.verifiedCategory) == null ? void 0 : _g.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
         }
-        lastIndex = placeholderRegex.lastIndex;
-      }
-      if (lastIndex < aiGeneratedContent.sentenceWithPlaceholders.length) {
-        segments.push({ type: "text", content: aiGeneratedContent.sentenceWithPlaceholders.substring(lastIndex) });
       }
+      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,
-        answers,
-        isCaseSensitive: (_a = aiGeneratedContent.isCaseSensitive) != null ? _a : clientInput.isCaseSensitive,
+        segments: finalSegments,
+        answers: finalAnswers,
+        isCaseSensitive: clientInput.isCaseSensitive,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
+        topic: aiGeneratedContent.topic || ((_h = clientInput.quizContext) == null ? void 0 : _h.originalTopic),
+        difficulty: clientInput.difficulty,
+        contextCode: (_i = clientInput.quizContext) == null ? void 0 : _i.plannedContextId,
+        bloomLevel: (_j = clientInput.quizContext) == null ? void 0 : _j.plannedBloomLevel,
+        learningObjective: (_k = clientInput.quizContext) == null ? void 0 : _k.originalLoId,
+        subject: (_l = clientInput.quizContext) == null ? void 0 : _l.originalSubject,
+        category: (_m = clientInput.quizContext) == null ? void 0 : _m.originalCategory,
+        imageUrl: clientInput.imageUrl
       };
-      try {
-        const validatedQuestion = FillInTheBlanksQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
+      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_ATTEMPTS;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
       }
-    } else {
-      throw new Error("AI did not return content for the Fill-In-The-Blanks question.");
     }
-  } catch (error) {
-    console.error("Error generating Fill-In-The-Blanks question:", error);
-    throw new Error(`Failed to generate Fill-In-The-Blanks question: ${error.message}`);
   }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate FITB question after ${MAX_RETRY_ATTEMPTS} attempts. Last error: ${lastError == null ? void 0 : lastError.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
 }
-function extractJsonFromMarkdown2(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-z.object({
-  topic: z.string().describe("The topic for the question."),
-  language: z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfPairs: z.number().int().min(2).max(8).optional().default(4).describe("Number of pairs to match (2-8)."),
-  shuffleOptions: z.boolean().optional().default(true).describe("Whether the options should be shuffled."),
-  contextDescription: z.string().optional().describe("A specific context or scenario for the question."),
-  selectedContextId: z.string().optional().describe("The ID of the selected context.")
+BaseQuestionGenerationClientInputSchema.extend({
+  numberOfPairs: z.number().int().min(2).max(8).optional().default(4),
+  shuffleOptions: z.boolean().optional().default(true)
 });
-z.object({
-  prompt: z.string().describe("The overall instruction (e.g., 'Match the terms to their definitions.')."),
-  correctPairs: z.array(
-    z.object({
-      promptText: z.string().min(1).describe("The text for a prompt item (e.g., a term)."),
-      optionText: z.string().min(1).describe("The text for the corresponding option item (e.g., its definition).")
-    })
-  ).min(2),
+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(),
-  topic: z.string().optional()
-});
-var MatchingQuestionZodSchema = z.object({
-  id: z.string(),
-  questionType: z.literal("matching"),
-  prompt: z.string().min(1),
-  prompts: z.array(z.object({ id: z.string(), content: z.string().min(1) })).min(2),
-  options: z.array(z.object({ id: z.string(), content: z.string().min(1) })).min(2),
-  correctAnswerMap: z.array(z.object({ promptId: z.string(), optionId: z.string() })).min(2),
-  shuffleOptions: z.boolean().optional(),
-  points: z.number().min(0).optional(),
-  explanation: z.string().optional()
-  // ... other fields
-}).refine((data) => {
-  const promptIds = new Set(data.prompts.map((p) => p.id));
-  const optionIds = new Set(data.options.map((o) => o.id));
-  return data.correctAnswerMap.every(
-    (map) => promptIds.has(map.promptId) && optionIds.has(map.optionId)
-  );
-}, {
-  message: "All IDs in correctAnswerMap must exist in the prompts and options arrays.",
-  path: ["correctAnswerMap"]
-}).refine((data) => {
-  const mappedPromptIds = new Set(data.correctAnswerMap.map((m) => m.promptId));
-  return mappedPromptIds.size === data.prompts.length && data.correctAnswerMap.length === data.prompts.length;
-}, {
-  message: "Each prompt must be mapped exactly once in the correctAnswerMap.",
-  path: ["correctAnswerMap"]
-});
-z.object({
-  question: MatchingQuestionZodSchema.optional().describe("The generated Matching question.")
+  topic: z.string().optional(),
+  verifiedCategory: z.string().optional()
+  // Thêm để xác thực
 });
-async function generateMatchingQuestion(clientInput, apiKey) {
-  try {
-    const ai = genkit({
-      plugins: [googleAI({ apiKey })],
-      model: gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer.
-Generate a single Matching question in ${clientInput.language} with exactly ${clientInput.numberOfPairs} correct pairs.
 
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "Match each country to its capital city.",
-  "correctPairs": [
-    { "promptText": "France", "optionText": "Paris" },
-    { "promptText": "Japan", "optionText": "Tokyo" },
-    { "promptText": "Egypt", "optionText": "Cairo" },
-    { "promptText": "Brazil", "optionText": "Bras\xEDlia" }
-  ],
-  "explanation": "These are the capital cities for the respective countries.",
-  "points": 10,
-  "difficulty": "medium",
-  "topic": "World Geography"
-}
+// src/ai/flows/question-gen/generate-matching-question.ts
+var MAX_RETRY_ATTEMPTS2 = 3;
+var RETRY_DELAY_MS2 = 3e3;
+function buildEnhancedPrompt2(clientInput, attemptNumber) {
+  const { quizContext, language, difficulty, numberOfPairs, imageUrl } = clientInput;
+  const category = (quizContext == null ? void 0 : 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.
 
-Requirements:
-- The 'correctPairs' array must contain exactly ${clientInput.numberOfPairs} objects.
-- Each object in 'correctPairs' must have a 'promptText' and its corresponding 'optionText'.
-- Ensure the content of all 'promptText' values are unique.
-- Ensure the content of all 'optionText' values are unique.
-- The content of 'prompt', 'correctPairs.promptText', 'correctPairs.optionText', 'explanation', and 'topic' must be in ${clientInput.language}.
+` : "";
+  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 == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : 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: "Match each Swift collection type to its primary characteristic.",
+    correctPairs: [
+      { "promptText": "Array", "optionText": "An ordered, random-access collection." },
+      { "promptText": "Set", "optionText": "An unordered collection of unique elements." },
+      { "promptText": "Dictionary", "optionText": "An unordered collection of key-value associations." }
+    ],
+    explanation: "These are the fundamental characteristics of Swift's main collection types.",
+    points: 10,
+    difficulty: "easy",
+    topic: "Swift Collection Types",
+    verifiedCategory: category
+  }, null, 2);
+  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
+Your mission is to create a high-quality, technically accurate Matching Question.
 
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-Difficulty: ${clientInput.difficulty}
-Number of Pairs: ${clientInput.numberOfPairs}
+## 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.
 
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown2(rawText);
-    console.log("AI Response:", jsonText);
-    const aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent) {
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Matching Question.
+
+### Input Parameters
+- **Topic for Question:** ${(quizContext == null ? void 0 : 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:
+
+${exampleJson}
+
+Now, generate the JSON for the requested question.`;
+}
+async function generateMatchingQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  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_ATTEMPTS2; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt2(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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 = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.text) || "";
+      const duration = Date.now() - startTime;
+      DebugLogger.logResponse(attempt, rawText);
+      if (!rawText) throw new Error("AI returned an empty response.");
+      const parsedJson = JSON.parse(rawText);
+      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
+      const aiGeneratedContent = AIMatchingOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
       if (aiGeneratedContent.correctPairs.length !== clientInput.numberOfPairs) {
-        throw new Error(`AI generated ${aiGeneratedContent.correctPairs.length} pairs, but ${clientInput.numberOfPairs} were requested.`);
+        throw new Error(`AI generated ${aiGeneratedContent.correctPairs.length} pairs, but ${clientInput.numberOfPairs} were required.`);
+      }
+      if ((_f = clientInput.quizContext) == null ? void 0 : _f.originalCategory) {
+        const verifiedCategory = (_g = aiGeneratedContent.verifiedCategory) == null ? void 0 : _g.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
       }
       const finalPrompts = [];
       const finalOptions = [];
@@ -318,38 +557,43 @@ Return only the JSON response.`;
         shuffleOptions: clientInput.shuffleOptions,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
+        topic: aiGeneratedContent.topic || ((_h = clientInput.quizContext) == null ? void 0 : _h.originalTopic),
+        difficulty: clientInput.difficulty,
+        contextCode: (_i = clientInput.quizContext) == null ? void 0 : _i.plannedContextId,
+        bloomLevel: (_j = clientInput.quizContext) == null ? void 0 : _j.plannedBloomLevel,
+        learningObjective: (_k = clientInput.quizContext) == null ? void 0 : _k.originalLoId,
+        subject: (_l = clientInput.quizContext) == null ? void 0 : _l.originalSubject,
+        category: (_m = clientInput.quizContext) == null ? void 0 : _m.originalCategory,
+        imageUrl: clientInput.imageUrl
       };
-      try {
-        const validatedQuestion = MatchingQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
+      const validatedQuestion = MatchingQuestionZodSchema.parse(completeQuestion);
+      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
+      console.log(`
+\u2705 Matching generation successful on attempt ${attempt} (${duration}ms)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } catch (error) {
+      lastError = error;
+      const duration = Date.now() - startTime;
+      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS2;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS2}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS2));
       }
-    } else {
-      throw new Error("AI did not return content for the Matching question.");
     }
-  } catch (error) {
-    console.error("Error generating Matching question:", error);
-    throw new Error(`Failed to generate Matching question: ${error.message}`);
   }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate Matching question after ${MAX_RETRY_ATTEMPTS2} attempts. Last error: ${lastError == null ? void 0 : lastError.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
 }
-function extractJsonFromMarkdown3(text) {
-  return text.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
-}
-z.object({
-  topic: z.string().describe("The topic for the question."),
-  language: z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfOptions: z.number().int().min(2).max(6).optional().default(4).describe("Number of answer options to generate (2-6)."),
-  contextDescription: z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: z.string().optional().describe("The ID of the selected context, if any.")
+BaseQuestionGenerationClientInputSchema.extend({
+  numberOfOptions: z.number().int().min(2).max(6).optional().default(4)
 });
-z.object({
+var AIMCQOutputFieldsSchema = z.object({
   prompt: z.string().describe("The question statement itself."),
   options: z.array(
     z.object({
@@ -359,99 +603,123 @@ z.object({
   ).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).describe("Points for a correct answer."),
-  difficulty: z.enum(["easy", "medium", "hard"]).optional().describe("Assessed difficulty."),
-  topic: z.string().optional().describe("Refined topic.")
-});
-var MultipleChoiceQuestionZodSchema = z.object({
-  id: z.string(),
-  questionType: z.literal("multiple_choice"),
-  prompt: z.string().min(1),
-  options: z.array(z.object({ id: z.string(), text: z.string().min(1) })).min(2).max(10),
-  correctAnswerId: z.string(),
-  points: z.number().min(0).optional(),
-  explanation: z.string().optional(),
-  learningObjective: z.string().optional(),
-  glossary: z.array(z.string()).optional(),
-  bloomLevel: z.string().optional(),
+  points: z.number().optional().default(10),
   difficulty: z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: z.string().optional(),
-  gradeBand: z.string().optional(),
-  course: z.string().optional(),
-  category: z.string().optional(),
-  topic: z.string().optional()
-}).refine((data) => {
-  return data.options.some((option) => option.id === data.correctAnswerId);
-}, {
-  message: "correctAnswerId must match one of the option IDs",
-  path: ["correctAnswerId"]
-}).refine((data) => {
-  const optionIds = data.options.map((opt) => opt.id);
-  return optionIds.length === new Set(optionIds).size;
-}, {
-  message: "All option IDs must be unique",
-  path: ["options"]
-});
-z.object({
-  question: MultipleChoiceQuestionZodSchema.optional().describe("The generated Multiple Choice question.")
+  topic: z.string().optional(),
+  verifiedCategory: z.string().optional().describe("The category this question actually addresses.")
 });
-async function generateMCQQuestion(clientInput, apiKey) {
-  try {
-    const ai = genkit({
-      plugins: [googleAI({ apiKey })],
-      model: gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer.
-Generate a single Multiple Choice question in ${clientInput.language} based on the following inputs.
 
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "Your question here",
-  "options": [
-    { "tempId": "A", "text": "First option text" },
-    { "tempId": "B", "text": "Second option text" },
-    { "tempId": "C", "text": "Third option text" },
-    { "tempId": "D", "text": "Fourth option text" }
-  ],
-  "correctTempOptionId": "C",
-  "explanation": "Brief explanation",
-  "points": 10,
-  "difficulty": "medium",
-  "topic": "refined topic"
-}
+// src/ai/flows/question-gen/generate-mcq-question.ts
+var MAX_RETRY_ATTEMPTS3 = 3;
+var RETRY_DELAY_MS3 = 3e3;
+function buildEnhancedPrompt3(clientInput, attemptNumber) {
+  const { quizContext, language, difficulty, numberOfOptions, imageUrl } = clientInput;
+  const category = (quizContext == null ? void 0 : quizContext.originalCategory) || "the specified technical category";
+  const attemptInfo = attemptNumber > 1 ? `
+## DEBUG INFO - This is attempt #${attemptNumber}
+Previous attempts failed...
 
-Requirements:
-- Generate exactly ${clientInput.numberOfOptions} options.
-- Use tempId values like "A", "B", "C", "D" or "option_1", "option_2", etc.
-- Make sure correctTempOptionId matches one of the tempId values in options array.
-- Each option must have both "tempId" and "text" fields.
-- The content of 'prompt', 'options.text', 'explanation', and 'topic' must be in ${clientInput.language}.
+` : "";
+  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 == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : quizContext.targetMisconception) && `**Target Misconception:** Use this to create plausible incorrect answers: "${quizContext.targetMisconception}"`,
+    (quizContext == null ? void 0 : 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?`,
+    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." }
+    ],
+    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: `Control Flow in ${category}`,
+    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.
 
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-${clientInput.contextDescription ? `Context: ${clientInput.contextDescription}` : ""}
-Difficulty: ${clientInput.difficulty}
-Number of Options: ${clientInput.numberOfOptions}
+## 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.
+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.
 
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown3(rawText);
-    console.log("AI Response:", jsonText);
-    let aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent.options && Array.isArray(aiGeneratedContent.options)) {
-      const normalizedOptions = aiGeneratedContent.options.map((option, index) => {
-        if (typeof option === "object" && !option.tempId) {
-          const key = Object.keys(option)[0];
-          const text = option[key];
-          return { tempId: key, text };
-        }
-        return option;
-      });
-      aiGeneratedContent.options = normalizedOptions;
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Multiple Choice Question.
+
+### Input Parameters
+- **Topic for Question:** ${(quizContext == null ? void 0 : quizContext.plannedTopic) || "General"}
+- **Language for Text:** ${language}
+- **Difficulty Level:** ${difficulty}
+- **Number of Options:** ${numberOfOptions}
+
+### Required JSON Output Format
+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 generateMCQQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const ai = new GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config = {
+    temperature: 0.8,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
     }
-    console.log("Normalized AI Content:", JSON.stringify(aiGeneratedContent, null, 2));
-    if (aiGeneratedContent) {
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS3; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt3(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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 = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.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 = AIMCQOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      if ((_f = clientInput.quizContext) == null ? void 0 : _f.originalCategory) {
+        const verifiedCategory = (_g = aiGeneratedContent.verifiedCategory) == null ? void 0 : _g.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
       const finalOptions = [];
       const tempIdToFinalIdMap = {};
       aiGeneratedContent.options.forEach((aiOption) => {
@@ -461,7 +729,7 @@ Return only the JSON response.`;
       });
       const finalCorrectAnswerId = tempIdToFinalIdMap[aiGeneratedContent.correctTempOptionId];
       if (!finalCorrectAnswerId) {
-        throw new Error(`Correct option ID '${aiGeneratedContent.correctTempOptionId}' is invalid or does not match any generated option tempId.`);
+        throw new Error(`Correct option ID '${aiGeneratedContent.correctTempOptionId}' is invalid`);
       }
       const completeQuestion = {
         id: generateUniqueId("mcq_ai_"),
@@ -471,173 +739,196 @@ Return only the JSON response.`;
         correctAnswerId: finalCorrectAnswerId,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
+        topic: aiGeneratedContent.topic || ((_h = clientInput.quizContext) == null ? void 0 : _h.originalTopic),
+        difficulty: clientInput.difficulty,
+        contextCode: (_i = clientInput.quizContext) == null ? void 0 : _i.plannedContextId,
+        bloomLevel: (_j = clientInput.quizContext) == null ? void 0 : _j.plannedBloomLevel,
+        learningObjective: (_k = clientInput.quizContext) == null ? void 0 : _k.originalLoId,
+        subject: (_l = clientInput.quizContext) == null ? void 0 : _l.originalSubject,
+        category: (_m = clientInput.quizContext) == null ? void 0 : _m.originalCategory,
+        imageUrl: clientInput.imageUrl
       };
-      try {
-        const validatedQuestion = MultipleChoiceQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
+      const validatedQuestion = MultipleChoiceQuestionZodSchema.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)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } catch (error) {
+      lastError = error;
+      const duration = Date.now() - startTime;
+      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS3;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS3}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS3));
       }
-    } else {
-      throw new Error("AI did not return content for the MCQ question.");
     }
-  } catch (error) {
-    console.error("Error generating MCQ question:", error);
-    throw new Error(`Failed to generate MCQ question: ${error.message}`);
   }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate MCQ question after ${MAX_RETRY_ATTEMPTS3} attempts. Last error: ${lastError == null ? void 0 : lastError.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
 }
-function extractJsonFromMarkdown4(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-z.object({
-  topic: z.string().describe("The topic for the question."),
-  language: z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfOptions: z.number().int().min(2).max(8).optional().default(5).describe("Number of answer options to generate (2-8)."),
-  minCorrectAnswers: z.number().int().min(1).optional().default(2).describe("Minimum number of correct answers among the options."),
-  maxCorrectAnswers: z.number().int().min(1).optional().default(3).describe("Maximum number of correct answers (must be <= numberOfOptions)."),
-  contextDescription: z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: z.string().optional().describe("The ID of the selected context, if any.")
-});
-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')."),
-      text: z.string().describe("The text content of this answer option.")
-    })
-  ).min(2).max(8),
-  correctTempOptionIds: z.array(z.string()).min(1).describe("An array of temporary IDs of the correct options."),
-  explanation: z.string().optional().describe("A brief explanation of why the answers are correct."),
-  points: z.number().optional().default(10).describe("Points for a correct answer."),
-  difficulty: z.enum(["easy", "medium", "hard"]).optional().describe("Assessed difficulty."),
-  topic: z.string().optional().describe("Refined topic.")
+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)
 });
-var MultipleResponseQuestionZodSchema = z.object({
-  id: z.string(),
-  questionType: z.literal("multiple_response"),
-  prompt: z.string().min(1),
-  options: z.array(z.object({ id: z.string(), text: z.string().min(1) })).min(2).max(10),
-  correctAnswerIds: z.array(z.string()).min(1),
-  points: z.number().min(0).optional(),
+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(),
-  learningObjective: z.string().optional(),
-  glossary: z.array(z.string()).optional(),
-  bloomLevel: z.string().optional(),
+  points: z.number().optional().default(10),
   difficulty: z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: z.string().optional(),
-  gradeBand: z.string().optional(),
-  course: z.string().optional(),
-  category: z.string().optional(),
-  topic: z.string().optional()
-}).refine((data) => {
-  const optionIds = new Set(data.options.map((option) => option.id));
-  return data.correctAnswerIds.every((correctId) => optionIds.has(correctId));
-}, {
-  message: "All correctAnswerIds must match one of the option IDs",
-  path: ["correctAnswerIds"]
-}).refine((data) => {
-  const optionIds = data.options.map((opt) => opt.id);
-  return optionIds.length === new Set(optionIds).size;
-}, {
-  message: "All option IDs must be unique",
-  path: ["options"]
-});
-z.object({
-  question: MultipleResponseQuestionZodSchema.optional().describe("The generated Multiple Response question.")
+  topic: z.string().optional(),
+  verifiedCategory: z.string().optional().describe("The category this question actually addresses.")
 });
-async function generateMRQQuestion(clientInput, apiKey) {
-  try {
-    if (clientInput.minCorrectAnswers > clientInput.maxCorrectAnswers) {
-      throw new Error("Minimum correct answers cannot exceed maximum correct answers.");
-    }
-    if (clientInput.maxCorrectAnswers >= clientInput.numberOfOptions) {
-      throw new Error("Maximum correct answers must be less than the total number of options.");
-    }
-    const ai = genkit({
-      plugins: [googleAI({ apiKey })],
-      model: gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer specializing in Multiple Response questions.
-Generate a single Multiple Response question in ${clientInput.language} based on the following inputs.
 
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "Your question here (e.g., 'Which of the following are primary colors?')",
-  "options": [
-    { "tempId": "A", "text": "First option" },
-    { "tempId": "B", "text": "Second option" },
-    { "tempId": "C", "text": "Third option" },
-    { "tempId": "D", "text": "Fourth option" },
-    { "tempId": "E", "text": "Fifth option" }
-  ],
-  "correctTempOptionIds": ["A", "C"],
-  "explanation": "Brief explanation of all correct answers.",
-  "points": 10,
-  "difficulty": "medium",
-  "topic": "refined topic"
-}
+// src/ai/flows/question-gen/generate-mrq-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 category = (quizContext == null ? void 0 : 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.
 
-Requirements:
-- Generate exactly ${clientInput.numberOfOptions} options.
-- Generate between ${clientInput.minCorrectAnswers} and ${clientInput.maxCorrectAnswers} correct answers.
-- Use tempId values like "A", "B", "C", etc.
-- Make sure all IDs in correctTempOptionIds match a tempId in the options array.
-- Each option must have both "tempId" and "text" fields.
-- The content of 'prompt', 'options.text', 'explanation', and 'topic' must be in ${clientInput.language}.
-
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-${clientInput.contextDescription ? `Context: ${clientInput.contextDescription}` : ""}
-Difficulty: ${clientInput.difficulty}
-Number of Options: ${clientInput.numberOfOptions}
-Min Correct Answers: ${clientInput.minCorrectAnswers}
-Max Correct Answers: ${clientInput.maxCorrectAnswers}
+` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and options must be directly related to the content of this image.` : "";
+  const contextStrings = [
+    `**Required Category:** ${category} (This is the ONLY language to be used)`,
+    (quizContext == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : quizContext.targetMisconception) && `**Target Misconception:** Use this to create plausible incorrect answers (distractors). The misconception is: "${quizContext.targetMisconception}"`,
+    (quizContext == null ? void 0 : quizContext.difficultyReason) && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
+  ].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.",
+    points: 10,
+    difficulty: "medium",
+    topic: "Programming Paradigms",
+    verifiedCategory: category
+  }, null, 2);
+  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in the programming language: ${category}.
+Your sole mission is to create a high-quality, technically accurate Multiple Response Question. You must adhere to the following rules at all times.
 
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown4(rawText);
-    console.log("AI Response:", jsonText);
-    let aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent.options && Array.isArray(aiGeneratedContent.options)) {
-      const normalizedOptions = aiGeneratedContent.options.map((option) => {
-        if (typeof option === "object" && !option.tempId && Object.keys(option).length === 1) {
-          const key = Object.keys(option)[0];
-          return { tempId: key, text: option[key] };
-        }
-        return option;
-      });
-      aiGeneratedContent.options = normalizedOptions;
+## 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.
+
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Multiple Response Question.
+
+### Input Parameters
+- **Topic for Question:** ${(quizContext == null ? void 0 : 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.
+
+${exampleJson}
+
+Now, generate the JSON for the requested question.`;
+}
+async function generateMRQQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  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 = {
+    temperature: 0.8,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
     }
-    console.log("Normalized AI Content:", JSON.stringify(aiGeneratedContent, null, 2));
-    if (aiGeneratedContent) {
-      const finalOptions = [];
-      const tempIdToFinalIdMap = {};
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS4; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt4(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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 = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.text) || "";
+      const duration = Date.now() - startTime;
+      DebugLogger.logResponse(attempt, rawText);
+      if (!rawText) {
+        throw new Error("AI returned an empty response.");
+      }
+      const parsedJson = JSON.parse(rawText);
+      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
+      const aiGeneratedContent = AIMRQOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      if (aiGeneratedContent.options.length !== clientInput.numberOfOptions) {
+        throw new Error(`AI generated ${aiGeneratedContent.options.length} options, but ${clientInput.numberOfOptions} were required.`);
+      }
+      const correctCount = aiGeneratedContent.correctTempOptionIds.length;
+      if (correctCount < clientInput.minCorrectAnswers || correctCount > clientInput.maxCorrectAnswers) {
+        throw new Error(`AI provided ${correctCount} correct answers, which is outside the required range of ${clientInput.minCorrectAnswers}-${clientInput.maxCorrectAnswers}.`);
+      }
+      if ((_f = clientInput.quizContext) == null ? void 0 : _f.originalCategory) {
+        const verifiedCategory = (_g = aiGeneratedContent.verifiedCategory) == null ? void 0 : _g.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
+      const finalOptions = [];
+      const tempIdToFinalIdMap = {};
+      const allTempIds = /* @__PURE__ */ new Set();
       aiGeneratedContent.options.forEach((aiOption) => {
         const finalId = generateUniqueId("opt_mr_");
         finalOptions.push({ id: finalId, text: aiOption.text });
         tempIdToFinalIdMap[aiOption.tempId] = finalId;
+        allTempIds.add(aiOption.tempId);
       });
       const finalCorrectAnswerIds = aiGeneratedContent.correctTempOptionIds.map((tempId) => {
-        const finalId = tempIdToFinalIdMap[tempId];
-        if (!finalId) {
-          throw new Error(`AI provided an invalid correctTempOptionId ('${tempId}') that does not map to any generated option.`);
+        if (!allTempIds.has(tempId)) {
+          throw new Error(`AI provided an invalid correctTempOptionId ('${tempId}') which does not exist in the generated options.`);
         }
-        return finalId;
+        return tempIdToFinalIdMap[tempId];
       });
-      if (finalCorrectAnswerIds.length < clientInput.minCorrectAnswers || finalCorrectAnswerIds.length > clientInput.maxCorrectAnswers) {
-        throw new Error(`AI generated ${finalCorrectAnswerIds.length} correct answers, which is outside the requested range of ${clientInput.minCorrectAnswers}-${clientInput.maxCorrectAnswers}.`);
-      }
-      if (finalOptions.length !== clientInput.numberOfOptions) {
-        throw new Error(`AI generated ${finalOptions.length} options, but ${clientInput.numberOfOptions} were requested.`);
-      }
       const completeQuestion = {
         id: generateUniqueId("mrq_ai_"),
         questionType: "multiple_response",
@@ -646,280 +937,348 @@ Return only the JSON response.`;
         correctAnswerIds: finalCorrectAnswerIds,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
+        topic: aiGeneratedContent.topic || ((_h = clientInput.quizContext) == null ? void 0 : _h.originalTopic),
         difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
+        contextCode: (_i = clientInput.quizContext) == null ? void 0 : _i.plannedContextId,
+        bloomLevel: (_j = clientInput.quizContext) == null ? void 0 : _j.plannedBloomLevel,
+        learningObjective: (_k = clientInput.quizContext) == null ? void 0 : _k.originalLoId,
+        subject: (_l = clientInput.quizContext) == null ? void 0 : _l.originalSubject,
+        category: (_m = clientInput.quizContext) == null ? void 0 : _m.originalCategory,
+        imageUrl: clientInput.imageUrl
       };
-      try {
-        const validatedQuestion = MultipleResponseQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
+      const validatedQuestion = MultipleResponseQuestionZodSchema.parse(completeQuestion);
+      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
+      console.log(`
+\u2705 MRQ generation successful on attempt ${attempt} (${duration}ms)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } catch (error) {
+      lastError = error;
+      const duration = Date.now() - startTime;
+      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS4;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS4}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS4));
       }
-    } else {
-      throw new Error("AI did not return content for the MRQ question.");
     }
-  } catch (error) {
-    console.error("Error generating MRQ question:", error);
-    throw new Error(`Failed to generate MRQ question: ${error.message}`);
   }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate MRQ question after ${MAX_RETRY_ATTEMPTS4} attempts. Last error: ${lastError == null ? void 0 : lastError.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
 }
-function extractJsonFromMarkdown5(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-z.object({
-  topic: z.string().describe("The topic for the question."),
-  language: z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  allowDecimals: z.boolean().optional().default(true).describe("Whether the answer can be a decimal."),
-  minRange: z.number().optional().describe("Optional minimum value for the answer."),
-  maxRange: z.number().optional().describe("Optional maximum value for the answer."),
-  contextDescription: z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: z.string().optional().describe("The ID of the selected context, if any.")
-});
-z.object({
-  prompt: z.string().describe("The question statement that expects a numerical answer."),
-  answer: z.number().describe("The precise numerical correct answer."),
-  tolerance: z.number().min(0).optional().default(0).describe("The acceptable range of error (plus or minus). Default is 0 for exact match."),
-  explanation: z.string().optional().describe("Explanation for the correct answer."),
-  points: z.number().optional().default(10),
-  difficulty: z.enum(["easy", "medium", "hard"]).optional(),
-  topic: z.string().optional()
+BaseQuestionGenerationClientInputSchema.extend({
+  allowDecimals: z.boolean().optional().default(true),
+  minRange: z.number().optional(),
+  maxRange: z.number().optional(),
+  // Thêm trường tolerance để client có thể tùy chỉnh
+  tolerance: z.number().min(0).optional().default(0)
 });
-var NumericQuestionZodSchema = z.object({
-  id: z.string(),
-  questionType: z.literal("numeric"),
-  prompt: z.string().min(1),
+var AINumericOutputFieldsSchema = z.object({
+  prompt: z.string(),
   answer: z.number(),
+  // AI có thể đề xuất một tolerance, nhưng chúng ta sẽ ưu tiên của client
   tolerance: z.number().min(0).optional(),
-  points: z.number().min(0).optional(),
   explanation: z.string().optional(),
-  learningObjective: z.string().optional(),
-  glossary: z.array(z.string()).optional(),
-  bloomLevel: z.string().optional(),
+  points: z.number().optional().default(10),
   difficulty: z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: z.string().optional(),
-  gradeBand: z.string().optional(),
-  course: z.string().optional(),
-  category: z.string().optional(),
-  topic: z.string().optional()
+  topic: z.string().optional(),
+  verifiedCategory: z.string().optional()
+  // Thêm để xác thực
 });
-z.object({
-  question: NumericQuestionZodSchema.optional().describe("The generated Numeric question.")
-});
-async function generateNumericQuestion(clientInput, apiKey) {
-  try {
-    if (clientInput.minRange !== void 0 && clientInput.maxRange !== void 0 && clientInput.minRange > clientInput.maxRange) {
-      throw new Error("minRange cannot be greater than maxRange.");
-    }
-    const ai = genkit({
-      plugins: [googleAI({ apiKey })],
-      model: gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer.
-Generate a single Numeric question in ${clientInput.language} based on the following inputs. The question must require a numerical answer.
 
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "Your question here (e.g., 'What is the value of Pi rounded to two decimal places?')",
-  "answer": 3.14,
-  "tolerance": 0.01,
-  "explanation": "Pi is an irrational number, approximately 3.14159. Rounding to two decimal places gives 3.14.",
-  "points": 10,
-  "difficulty": "easy",
-  "topic": "Mathematics"
-}
+// src/ai/flows/question-gen/generate-numeric-question.ts
+var MAX_RETRY_ATTEMPTS5 = 3;
+var RETRY_DELAY_MS5 = 3e3;
+function buildEnhancedPrompt5(clientInput, attemptNumber) {
+  const { quizContext, language, difficulty, minRange, maxRange, allowDecimals, imageUrl } = clientInput;
+  const category = (quizContext == null ? void 0 : quizContext.originalCategory) || "the specified technical category";
+  const attemptInfo = attemptNumber > 1 ? `
+## DEBUG INFO - This is attempt #${attemptNumber}
+Previous attempts failed. Ensure the 'answer' is a valid number and fits within the specified constraints.
 
-Requirements:
-- The 'answer' must be a number.
-- If 'allowDecimals' is false, the 'answer' must be an integer.
-- 'tolerance' is the acceptable error range (+/-). A tolerance of 0 means the answer must be exact.
-- The content of 'prompt', 'explanation', and 'topic' must be in ${clientInput.language}.
-${clientInput.minRange !== void 0 ? `- The answer should ideally be >= ${clientInput.minRange}.` : ""}
-${clientInput.maxRange !== void 0 ? `- The answer should ideally be <= ${clientInput.maxRange}.` : ""}
+` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and its numerical answer must be directly related to the content of this image.` : "";
+  const contextStrings = [
+    `**Required Category:** ${category}`,
+    (quizContext == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : quizContext.targetMisconception) && `**Target Misconception:** The question should clarify this numerical error: "${quizContext.targetMisconception}"`
+  ].filter(Boolean).map((s) => `- ${s}`).join("\n");
+  const constraintStrings = [
+    minRange !== void 0 && `The final 'answer' MUST be greater than or equal to ${minRange}.`,
+    maxRange !== void 0 && `The final 'answer' MUST be less than or equal to ${maxRange}.`,
+    !allowDecimals && `The final 'answer' MUST be an integer (whole number).`
+  ].filter(Boolean).join("\n");
+  const exampleJson = JSON.stringify({
+    prompt: "A Swift `Int` on a 64-bit platform can store a maximum value of 2^63 - 1. What is the maximum value for an `Int8`?",
+    answer: 127,
+    tolerance: 0,
+    explanation: "An Int8 uses 8 bits. One bit is for the sign, leaving 7 bits for the value. The range is from -128 to 127 (2^7 - 1).",
+    points: 10,
+    difficulty: "medium",
+    topic: "Swift Data Types",
+    verifiedCategory: category
+  }, null, 2);
+  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
+Your mission is to create a high-quality, technically accurate Numeric Question.
 
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-${clientInput.contextDescription ? `Context: ${clientInput.contextDescription}` : ""}
-Difficulty: ${clientInput.difficulty}
-Allow Decimals: ${clientInput.allowDecimals}
+## Core Rules (Non-negotiable)
+1.  **Category Purity:** The question MUST be exclusively about **${category}**.
+2.  **Quantitative Answer:** The question MUST ask for a specific, objective numerical answer.
+3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object.
 
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown5(rawText);
-    console.log("AI Response:", jsonText);
-    const aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent) {
-      let finalAnswer = aiGeneratedContent.answer;
-      if (!clientInput.allowDecimals) {
-        finalAnswer = Math.round(finalAnswer);
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Numeric Question.
+
+### Input Parameters & Constraints
+- **Topic for Question:** ${(quizContext == null ? void 0 : quizContext.plannedTopic) || "General"}
+- **Language for Text:** ${language}
+- **Difficulty Level:** ${difficulty}
+${constraintStrings ? `
+### CRITICAL CONSTRAINTS ON THE ANSWER
+${constraintStrings}` : ""}
+
+### 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 generateNumericQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+  if (clientInput.minRange !== void 0 && clientInput.maxRange !== void 0 && clientInput.minRange > clientInput.maxRange) {
+    return { error: `Invalid input: minRange (${clientInput.minRange}) cannot be greater than maxRange (${clientInput.maxRange}).` };
+  }
+  const ai = new GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config = {
+    temperature: 0.4,
+    // Giữ nhiệt độ thấp cho các câu trả lời chính xác
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
+    }
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS5; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt5(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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 = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.text) || "";
+      const duration = Date.now() - startTime;
+      DebugLogger.logResponse(attempt, rawText);
+      if (!rawText) throw new Error("AI returned an empty response.");
+      const parsedJson = JSON.parse(rawText);
+      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
+      const aiGeneratedContent = AINumericOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      const answer = aiGeneratedContent.answer;
+      if (clientInput.minRange !== void 0 && answer < clientInput.minRange) {
+        throw new Error(`AI answer ${answer} is less than the required minRange of ${clientInput.minRange}.`);
       }
-      if (clientInput.minRange !== void 0 && finalAnswer < clientInput.minRange) {
-        console.warn(`AI generated answer ${finalAnswer} is below the requested minRange of ${clientInput.minRange}.`);
+      if (clientInput.maxRange !== void 0 && answer > clientInput.maxRange) {
+        throw new Error(`AI answer ${answer} is greater than the required maxRange of ${clientInput.maxRange}.`);
       }
-      if (clientInput.maxRange !== void 0 && finalAnswer > clientInput.maxRange) {
-        console.warn(`AI generated answer ${finalAnswer} is above the requested maxRange of ${clientInput.maxRange}.`);
+      if (!clientInput.allowDecimals && !Number.isInteger(answer)) {
+        throw new Error(`AI answer ${answer} is not an integer, but decimals are not allowed.`);
+      }
+      if ((_f = clientInput.quizContext) == null ? void 0 : _f.originalCategory) {
+        const verifiedCategory = (_g = aiGeneratedContent.verifiedCategory) == null ? void 0 : _g.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
       }
       const completeQuestion = {
         id: generateUniqueId("num_ai_"),
         questionType: "numeric",
         prompt: aiGeneratedContent.prompt,
-        answer: finalAnswer,
-        tolerance: aiGeneratedContent.tolerance,
+        answer: aiGeneratedContent.answer,
+        tolerance: (_i = (_h = clientInput.tolerance) != null ? _h : aiGeneratedContent.tolerance) != null ? _i : 0,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
+        topic: aiGeneratedContent.topic || ((_j = clientInput.quizContext) == null ? void 0 : _j.originalTopic),
+        difficulty: clientInput.difficulty,
+        contextCode: (_k = clientInput.quizContext) == null ? void 0 : _k.plannedContextId,
+        bloomLevel: (_l = clientInput.quizContext) == null ? void 0 : _l.plannedBloomLevel,
+        learningObjective: (_m = clientInput.quizContext) == null ? void 0 : _m.originalLoId,
+        subject: (_n = clientInput.quizContext) == null ? void 0 : _n.originalSubject,
+        category: (_o = clientInput.quizContext) == null ? void 0 : _o.originalCategory,
+        imageUrl: clientInput.imageUrl
       };
-      try {
-        const validatedQuestion = NumericQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
+      const validatedQuestion = NumericQuestionZodSchema.parse(completeQuestion);
+      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
+      console.log(`
+\u2705 Numeric generation successful on attempt ${attempt} (${duration}ms)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } catch (error) {
+      lastError = error;
+      const duration = Date.now() - startTime;
+      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS5;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS5}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS5));
       }
-    } else {
-      throw new Error("AI did not return content for the Numeric question.");
     }
-  } catch (error) {
-    console.error("Error generating Numeric question:", error);
-    throw new Error(`Failed to generate Numeric question: ${error.message}`);
   }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate Numeric question after ${MAX_RETRY_ATTEMPTS5} attempts. Last error: ${lastError == null ? void 0 : lastError.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
 }
-function extractJsonFromMarkdown6(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-z.object({
-  topic: z.string().describe("The topic for the question."),
-  language: z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  numberOfItems: z.number().int().min(2).max(10).optional().default(4).describe("Number of items to sequence (2-10)."),
-  contextDescription: z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: z.string().optional().describe("The ID of the selected context, if any.")
-});
-z.object({
-  prompt: z.string().describe("The instruction for sequencing."),
-  itemsContent: z.array(z.string().min(1)).min(2).describe("An array of strings for each item to be sequenced."),
-  correctOrderContent: z.array(z.string().min(1)).min(2).describe("An array of the same strings from 'itemsContent', but in the correct sequence."),
-  explanation: z.string().optional().describe("Explanation for the correct sequence."),
-  points: z.number().optional().default(10),
-  difficulty: z.enum(["easy", "medium", "hard"]).optional(),
-  topic: z.string().optional()
+BaseQuestionGenerationClientInputSchema.extend({
+  numberOfItems: z.number().int().min(2).max(10).optional().default(4)
 });
-var SequenceQuestionZodSchema = z.object({
-  id: z.string(),
-  questionType: z.literal("sequence"),
-  prompt: z.string().min(1),
-  items: z.array(z.object({ id: z.string(), content: z.string().min(1) })).min(2),
-  correctOrder: z.array(z.string()).min(2),
-  // Array of item IDs
-  points: z.number().min(0).optional(),
+var AISequenceOutputFieldsSchema = z.object({
+  prompt: z.string().describe("The instructional text for the user, e.g., 'Arrange the steps in the correct order.'"),
+  // Yêu cầu AI cung cấp các item dưới dạng một mảng duy nhất đã được sắp xếp đúng thứ tự
+  // Điều này đơn giản hóa logic và giảm rủi ro
+  itemsInCorrectOrder: z.array(z.string().min(1)).min(2).describe("An array of strings, with each string representing an item to be sequenced. The array itself MUST be in the correct final order."),
   explanation: z.string().optional(),
-  learningObjective: z.string().optional(),
-  glossary: z.array(z.string()).optional(),
-  bloomLevel: z.string().optional(),
+  points: z.number().optional().default(10),
   difficulty: z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: z.string().optional(),
-  gradeBand: z.string().optional(),
-  course: z.string().optional(),
-  category: z.string().optional(),
-  topic: z.string().optional()
-}).refine((data) => {
-  const itemIds = new Set(data.items.map((item) => item.id));
-  return data.correctOrder.every((id) => itemIds.has(id));
-}, {
-  message: "Every ID in correctOrder must correspond to an item in the items array.",
-  path: ["correctOrder"]
-}).refine((data) => {
-  return new Set(data.correctOrder).size === data.items.length && data.correctOrder.length === data.items.length;
-}, {
-  message: "The correctOrder array must contain all item IDs exactly once.",
-  path: ["correctOrder"]
-}).refine((data) => {
-  const itemIds = data.items.map((item) => item.id);
-  return itemIds.length === new Set(itemIds).size;
-}, {
-  message: "All item IDs must be unique.",
-  path: ["items"]
-});
-z.object({
-  question: SequenceQuestionZodSchema.optional().describe("The generated Sequence question.")
+  topic: z.string().optional(),
+  verifiedCategory: z.string().optional()
+  // Thêm để xác thực
 });
-async function generateSequenceQuestion(clientInput, apiKey) {
-  try {
-    const ai = genkit({
-      plugins: [googleAI({ apiKey })],
-      model: gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer specializing in Sequence questions.
-Generate a single Sequence question in ${clientInput.language} based on the following inputs.
 
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "Arrange the following events of World War II in chronological order.",
-  "itemsContent": [
-    "D-Day (Normandy Landings)",
-    "Invasion of Poland",
-    "Attack on Pearl Harbor",
-    "Battle of Stalingrad"
-  ],
-  "correctOrderContent": [
-    "Invasion of Poland",
-    "Attack on Pearl Harbor",
-    "Battle of Stalingrad",
-    "D-Day (Normandy Landings)"
-  ],
-  "explanation": "The Invasion of Poland started the war in Europe, followed by the US entry after Pearl Harbor, the turning point at Stalingrad, and finally the D-Day invasion.",
-  "points": 10,
-  "difficulty": "medium",
-  "topic": "World War II History"
-}
+// src/ai/flows/question-gen/generate-sequence-question.ts
+var MAX_RETRY_ATTEMPTS6 = 3;
+var RETRY_DELAY_MS6 = 3e3;
+function buildEnhancedPrompt6(clientInput, attemptNumber) {
+  const { quizContext, language, difficulty, numberOfItems, imageUrl } = clientInput;
+  const category = (quizContext == null ? void 0 : quizContext.originalCategory) || "the specified technical category";
+  const attemptInfo = attemptNumber > 1 ? `
+## DEBUG INFO - This is attempt #${attemptNumber}
+Previous attempts failed. Ensure the 'itemsInCorrectOrder' array has exactly the required number of items and the JSON is valid.
 
-Requirements:
-- Generate exactly ${clientInput.numberOfItems} items to be sequenced.
-- The 'itemsContent' array should contain the text for each item.
-- The 'correctOrderContent' array must contain the exact same strings as 'itemsContent', but arranged in the correct sequence.
-- Both arrays must have the same number of elements.
-- The content of 'prompt', 'itemsContent', 'correctOrderContent', 'explanation', and 'topic' must be in ${clientInput.language}.
+` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The sequence of items must be directly related to the process or content shown in this image.` : "";
+  const contextStrings = [
+    `**Required Category:** ${category}`,
+    (quizContext == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : quizContext.targetMisconception) && `**Target Misconception:** The sequence should clarify this specific process error: "${quizContext.targetMisconception}"`
+  ].filter(Boolean).map((s) => `- ${s}`).join("\n");
+  const exampleJson = JSON.stringify({
+    prompt: "Arrange the steps to make a network request in Swift using URLSession.",
+    itemsInCorrectOrder: [
+      "Create a URL object.",
+      "Create a URLSessionDataTask with the URL.",
+      "Start the task by calling its resume() method.",
+      "Handle the completion handler with data, response, and error."
+    ],
+    explanation: "This is the fundamental sequence for a basic data task in URLSession.",
+    points: 10,
+    difficulty: "medium",
+    topic: "Swift Networking",
+    verifiedCategory: category
+  }, null, 2);
+  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
+Your mission is to create a high-quality, technically accurate Sequence Question.
 
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-${clientInput.contextDescription ? `Context: ${clientInput.contextDescription}` : ""}
-Difficulty: ${clientInput.difficulty}
-Number of Items: ${clientInput.numberOfItems}
+## Core Rules (Non-negotiable)
+1.  **Category Purity:** The question MUST be exclusively about **${category}**.
+2.  **Unambiguous Order:** The items MUST represent a clear, objective process, timeline, or order with only one correct sequence.
+3.  **Schema Integrity:** The response MUST be ONLY a single, valid JSON object that strictly follows the provided schema.
 
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown6(rawText);
-    console.log("AI Response:", jsonText);
-    const aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent) {
-      if (aiGeneratedContent.itemsContent.length !== clientInput.numberOfItems || aiGeneratedContent.correctOrderContent.length !== clientInput.numberOfItems) {
-        throw new Error(`AI generated an incorrect number of items. Requested: ${clientInput.numberOfItems}, Got: ${aiGeneratedContent.itemsContent.length} items and ${aiGeneratedContent.correctOrderContent.length} in correct order.`);
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Sequence Question.
+
+### Input Parameters
+- **Topic for Question:** ${(quizContext == null ? void 0 : quizContext.plannedTopic) || "General"}
+- **Language for Text:** ${language}
+- **Difficulty Level:** ${difficulty}
+- **Number of Items:** Generate an array 'itemsInCorrectOrder' containing exactly ${numberOfItems} items. The array itself MUST be in the correct final sequence.
+
+### Required JSON Output Format
+Your response must be ONLY the JSON object, matching this exact structure:
+
+${exampleJson}
+
+Now, generate the JSON for the requested question.`;
+}
+async function generateSequenceQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const ai = new GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config = {
+    temperature: 0.7,
+    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, __spreadProps(__spreadValues({}, clientInput), { attemptNumber: attempt, promptHash }));
+      const parts = [{ text: promptText }];
+      if (clientInput.imageUrl) {
+        const mimeType = clientInput.imageUrl.endsWith(".png") ? "image/png" : "image/jpeg";
+        const imagePart = await urlToGenerativePart(clientInput.imageUrl, mimeType);
+        parts.unshift(imagePart);
       }
-      if (new Set(aiGeneratedContent.itemsContent).size !== new Set(aiGeneratedContent.correctOrderContent).size) {
-        throw new Error("The set of items in 'itemsContent' and 'correctOrderContent' do not match.");
+      const contents = [{ role: "user", parts }];
+      const aiResult = await ai.models.generateContent({ model, config, contents });
+      const response = aiResult;
+      const rawText = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.text) || "";
+      const duration = Date.now() - startTime;
+      DebugLogger.logResponse(attempt, rawText);
+      if (!rawText) throw new Error("AI returned an empty response.");
+      const parsedJson = JSON.parse(rawText);
+      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
+      const aiGeneratedContent = AISequenceOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      if (aiGeneratedContent.itemsInCorrectOrder.length !== clientInput.numberOfItems) {
+        throw new Error(`AI generated ${aiGeneratedContent.itemsInCorrectOrder.length} items, but ${clientInput.numberOfItems} were required.`);
       }
-      const contentToIdMap = {};
-      const finalItems = aiGeneratedContent.itemsContent.map((content) => {
-        const id = generateUniqueId("seqi_");
-        contentToIdMap[content] = id;
-        return { id, content };
-      });
-      const finalCorrectOrder = aiGeneratedContent.correctOrderContent.map((content) => {
-        const id = contentToIdMap[content];
-        if (!id) {
-          throw new Error(`Content "${content}" from 'correctOrderContent' was not found in 'itemsContent'.`);
+      if ((_f = clientInput.quizContext) == null ? void 0 : _f.originalCategory) {
+        const verifiedCategory = (_g = aiGeneratedContent.verifiedCategory) == null ? void 0 : _g.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
         }
-        return id;
+      }
+      const finalItems = [];
+      const finalCorrectOrder = [];
+      aiGeneratedContent.itemsInCorrectOrder.forEach((content) => {
+        const id = generateUniqueId("seqi_");
+        finalItems.push({ id, content });
+        finalCorrectOrder.push(id);
       });
       const completeQuestion = {
         id: generateUniqueId("seq_ai_"),
@@ -929,212 +1288,307 @@ Return only the JSON response.`;
         correctOrder: finalCorrectOrder,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
+        topic: aiGeneratedContent.topic || ((_h = clientInput.quizContext) == null ? void 0 : _h.originalTopic),
+        difficulty: clientInput.difficulty,
+        contextCode: (_i = clientInput.quizContext) == null ? void 0 : _i.plannedContextId,
+        bloomLevel: (_j = clientInput.quizContext) == null ? void 0 : _j.plannedBloomLevel,
+        learningObjective: (_k = clientInput.quizContext) == null ? void 0 : _k.originalLoId,
+        subject: (_l = clientInput.quizContext) == null ? void 0 : _l.originalSubject,
+        category: (_m = clientInput.quizContext) == null ? void 0 : _m.originalCategory,
+        imageUrl: clientInput.imageUrl
       };
-      try {
-        const validatedQuestion = SequenceQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
+      const validatedQuestion = SequenceQuestionZodSchema.parse(completeQuestion);
+      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
+      console.log(`
+\u2705 Sequence generation successful on attempt ${attempt} (${duration}ms)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } catch (error) {
+      lastError = error;
+      const duration = Date.now() - startTime;
+      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
+      const willRetry = attempt < MAX_RETRY_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));
       }
-    } else {
-      throw new Error("AI did not return content for the Sequence question.");
     }
-  } catch (error) {
-    console.error("Error generating Sequence question:", error);
-    throw new Error(`Failed to generate Sequence question: ${error.message}`);
   }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate Sequence question after ${MAX_RETRY_ATTEMPTS6} attempts. Last error: ${lastError == null ? void 0 : lastError.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
 }
-function extractJsonFromMarkdown7(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-z.object({
-  topic: z.string().describe("The topic for the question."),
-  language: z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  isCaseSensitive: z.boolean().optional().default(false).describe("Whether the answer should be case-sensitive."),
-  contextDescription: z.string().optional().describe("A specific context or scenario for the question, complementing the main topic."),
-  selectedContextId: z.string().optional().describe("The ID of the selected context, if any.")
-});
-z.object({
-  prompt: z.string().describe("The question statement."),
-  acceptedAnswers: z.array(z.string().min(1)).min(1).describe("An array of acceptable short answers."),
-  isCaseSensitive: z.boolean().optional().describe("Should the answer evaluation be case sensitive?"),
-  explanation: z.string().optional().describe("Explanation for the correct answer(s)."),
-  points: z.number().optional().default(10),
-  difficulty: z.enum(["easy", "medium", "hard"]).optional(),
-  topic: z.string().optional()
+BaseQuestionGenerationClientInputSchema.extend({
+  isCaseSensitive: z.boolean().optional().default(false)
 });
-var ShortAnswerQuestionZodSchema = z.object({
-  id: z.string(),
-  questionType: z.literal("short_answer"),
-  prompt: z.string().min(1),
-  acceptedAnswers: z.array(z.string().min(1)).min(1),
-  isCaseSensitive: z.boolean().optional(),
-  points: z.number().min(0).optional(),
+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(),
-  learningObjective: z.string().optional(),
-  glossary: z.array(z.string()).optional(),
-  bloomLevel: z.string().optional(),
+  points: z.number().optional().default(10),
   difficulty: z.enum(["easy", "medium", "hard"]).optional(),
-  contextCode: z.string().optional(),
-  gradeBand: z.string().optional(),
-  course: z.string().optional(),
-  category: z.string().optional(),
-  topic: z.string().optional()
-});
-z.object({
-  question: ShortAnswerQuestionZodSchema.optional().describe("The generated Short Answer question.")
+  topic: z.string().optional(),
+  verifiedCategory: z.string().optional()
+  // Thêm để xác thực
 });
-async function generateShortAnswerQuestion(clientInput, apiKey) {
-  var _a;
-  try {
-    const ai = genkit({
-      plugins: [googleAI({ apiKey })],
-      model: gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer.
-Generate a single Short Answer question in ${clientInput.language} based on the following inputs.
 
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "What is the capital of France?",
-  "acceptedAnswers": ["Paris"],
-  "isCaseSensitive": false,
-  "explanation": "Paris has been the capital of France since the 10th century.",
-  "points": 5,
-  "difficulty": "easy",
-  "topic": "World Capitals"
-}
+// 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;
+  const category = (quizContext == null ? void 0 : 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.
 
-Requirements:
-- The 'acceptedAnswers' array must contain at least one possible correct answer.
-- If there are multiple common ways to phrase the answer (e.g., "USA", "United States"), include them in the array.
-- Set 'isCaseSensitive' to true or false based on the nature of the answer. Default to the input value.
-- The content of 'prompt', 'acceptedAnswers', 'explanation', and 'topic' must be in ${clientInput.language}.
+` : "";
+  const imageContextInstruction = imageUrl ? `**Image Context:** You MUST analyze the provided image. The question and its short answer must be directly related to the content of this image.` : "";
+  const contextStrings = [
+    `**Required Category:** ${category}`,
+    (quizContext == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : 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: "In Swift, what keyword is used to declare a constant?",
+    acceptedAnswers: ["let"],
+    explanation: "The 'let' keyword is used to declare constants, which are values that cannot be changed after they are set. 'var' is used for variables.",
+    points: 10,
+    difficulty: "easy",
+    topic: "Swift Constants",
+    verifiedCategory: category
+  }, null, 2);
+  return `${attemptInfo}You are an expert Question Author for advanced technical education, specializing in: ${category}.
+Your mission is to create a high-quality, technically accurate Short Answer Question.
 
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-${clientInput.contextDescription ? `Context: ${clientInput.contextDescription}` : ""}
-Difficulty: ${clientInput.difficulty}
-Case Sensitive: ${clientInput.isCaseSensitive}
+## 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.
 
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown7(rawText);
-    console.log("AI Response:", jsonText);
-    const aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent) {
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+Based on all the rules and context above, generate a single Short Answer Question.
+
+### Input Parameters
+- **Topic for Question:** ${(quizContext == null ? void 0 : quizContext.plannedTopic) || "General"}
+- **Language for Text:** ${language}
+- **Difficulty Level:** ${difficulty}
+
+### Required JSON Output Format
+Your response must be ONLY the JSON object, matching this exact structure:
+
+${exampleJson}
+
+Now, generate the JSON for the requested question.`;
+}
+async function generateShortAnswerQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const ai = new GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config = {
+    temperature: 0.5,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
+    }
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS7; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt7(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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 = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.text) || "";
+      const duration = Date.now() - startTime;
+      DebugLogger.logResponse(attempt, rawText);
+      if (!rawText) throw new Error("AI returned an empty response.");
+      const parsedJson = JSON.parse(rawText);
+      DebugLogger.logValidation(attempt, "JSON Parsed Successfully", parsedJson);
+      const aiGeneratedContent = AIShortAnswerOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      if ((_f = clientInput.quizContext) == null ? void 0 : _f.originalCategory) {
+        const verifiedCategory = (_g = aiGeneratedContent.verifiedCategory) == null ? void 0 : _g.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
       const completeQuestion = {
         id: generateUniqueId("saq_ai_"),
         questionType: "short_answer",
         prompt: aiGeneratedContent.prompt,
         acceptedAnswers: aiGeneratedContent.acceptedAnswers,
-        // Ưu tiên giá trị từ AI, nếu không có thì dùng giá trị đầu vào
-        isCaseSensitive: (_a = aiGeneratedContent.isCaseSensitive) != null ? _a : clientInput.isCaseSensitive,
+        isCaseSensitive: clientInput.isCaseSensitive,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
+        topic: aiGeneratedContent.topic || ((_h = clientInput.quizContext) == null ? void 0 : _h.originalTopic),
+        difficulty: clientInput.difficulty,
+        contextCode: (_i = clientInput.quizContext) == null ? void 0 : _i.plannedContextId,
+        bloomLevel: (_j = clientInput.quizContext) == null ? void 0 : _j.plannedBloomLevel,
+        learningObjective: (_k = clientInput.quizContext) == null ? void 0 : _k.originalLoId,
+        subject: (_l = clientInput.quizContext) == null ? void 0 : _l.originalSubject,
+        category: (_m = clientInput.quizContext) == null ? void 0 : _m.originalCategory,
+        imageUrl: clientInput.imageUrl
       };
-      try {
-        const validatedQuestion = ShortAnswerQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
+      const validatedQuestion = ShortAnswerQuestionZodSchema.parse(completeQuestion);
+      attemptResults.push({ success: true, duration, promptLength: promptText.length, responseLength: rawText.length, promptHash });
+      console.log(`
+\u2705 Short Answer generation successful on attempt ${attempt} (${duration}ms)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } catch (error) {
+      lastError = error;
+      const duration = Date.now() - startTime;
+      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS7;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS7}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS7));
       }
-    } else {
-      throw new Error("AI did not return content for the Short Answer question.");
     }
-  } catch (error) {
-    console.error("Error generating Short Answer question:", error);
-    throw new Error(`Failed to generate Short Answer question: ${error.message}`);
   }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate Short Answer question after ${MAX_RETRY_ATTEMPTS7} attempts. Last error: ${lastError == null ? void 0 : lastError.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
 }
-function extractJsonFromMarkdown8(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-z.object({
-  topic: z.string().describe("The topic for the question."),
-  language: z.string().optional().default("English").describe('The language for the generated question (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  difficulty: z.enum(["easy", "medium", "hard"]).optional().default("medium"),
-  contextDescription: z.string().optional().describe("A specific context or scenario for the question."),
-  selectedContextId: z.string().optional().describe("The ID of the selected context.")
-});
-z.object({
-  prompt: z.string().describe("The statement to be evaluated as true or false."),
-  correctAnswer: z.boolean().describe("The correct answer (true or false)."),
-  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()
-});
-var TrueFalseQuestionZodSchema = z.object({
-  id: z.string(),
-  questionType: z.literal("true_false"),
-  prompt: z.string().min(1),
+BaseQuestionGenerationClientInputSchema.extend({});
+var AITrueFalseOutputFieldsSchema = z.object({
+  prompt: z.string().describe("The statement that the user will evaluate as true or false."),
   correctAnswer: z.boolean(),
-  points: z.number().min(0).optional(),
-  explanation: z.string().optional(),
-  learningObjective: z.string().optional(),
-  glossary: z.array(z.string()).optional(),
-  bloomLevel: z.string().optional(),
+  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(),
-  contextCode: z.string().optional(),
-  gradeBand: z.string().optional(),
-  course: z.string().optional(),
-  category: z.string().optional(),
-  topic: z.string().optional()
+  topic: z.string().optional(),
+  verifiedCategory: z.string().optional()
+  // Thêm để xác thực
 });
-z.object({
-  question: TrueFalseQuestionZodSchema.optional().describe("The generated True/False question.")
-});
-async function generateTrueFalseQuestion(clientInput, apiKey) {
-  try {
-    const ai = genkit({
-      plugins: [googleAI({ apiKey })],
-      model: gemini20Flash
-    });
-    const promptText = `You are an expert quiz question writer.
-Generate a single True/False question in ${clientInput.language} based on the following inputs.
 
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "prompt": "The Earth is the fourth planet from the Sun.",
-  "correctAnswer": false,
-  "explanation": "The Earth is the third planet from the Sun. Mars is the fourth.",
-  "points": 10,
-  "difficulty": "easy",
-  "topic": "Astronomy"
-}
+// 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 == null ? void 0 : quizContext.originalCategory) || "the specified technical category";
+  const attemptInfo = attemptNumber > 1 ? `
+## DEBUG INFO - This is attempt #${attemptNumber}
+Previous attempts failed. Ensure the JSON is valid and 'correctAnswer' is a boolean.
 
-Requirements:
-- The 'prompt' must be a clear statement that is definitively true or false.
-- 'correctAnswer' must be a boolean value (true or false).
-- The content of 'prompt', 'explanation', and 'topic' must be in ${clientInput.language}.
+` : "";
+  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 == null ? void 0 : 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 == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    misconceptionGuidance,
+    (quizContext == null ? void 0 : quizContext.difficultyReason) && `**Pedagogical Reason:** ${quizContext.difficultyReason}`
+  ].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
+  }, 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.
 
-Topic: ${clientInput.topic}
-Language: ${clientInput.language}
-${clientInput.contextDescription ? `Context: ${clientInput.contextDescription}` : ""}
-Difficulty: ${clientInput.difficulty}
+## 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.
 
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown8(rawText);
-    console.log("AI Response:", jsonText);
-    const aiGeneratedContent = JSON.parse(jsonText);
-    if (aiGeneratedContent) {
+## 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 == null ? void 0 : quizContext.plannedTopic) || "General"}
+- **Language for Text:** ${language}
+- **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 generateTrueFalseQuestion(clientInput, apiKey) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+  const ai = new GoogleGenAI({ apiKey });
+  const model = "gemini-2.5-flash";
+  const config = {
+    temperature: 0.6,
+    responseMimeType: "application/json",
+    thinkingConfig: {
+      thinkingBudget: 4e3
+    }
+  };
+  const attemptResults = [];
+  let lastError = null;
+  for (let attempt = 1; attempt <= MAX_RETRY_ATTEMPTS8; attempt++) {
+    const startTime = Date.now();
+    const promptText = buildEnhancedPrompt8(clientInput, attempt);
+    const promptHash = Buffer.from(promptText).toString("base64").slice(0, 10);
+    try {
+      DebugLogger.logPrompt(attempt, promptText, __spreadProps(__spreadValues({}, 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 = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.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 = AITrueFalseOutputFieldsSchema.parse(parsedJson);
+      DebugLogger.logValidation(attempt, "Zod Schema Validated", aiGeneratedContent);
+      if (((_f = clientInput.quizContext) == null ? void 0 : _f.targetMisconception) && aiGeneratedContent.correctAnswer === true) {
+        throw new Error("AI failed to follow the Misconception Priority rule. The answer should have been false.");
+      }
+      if ((_g = clientInput.quizContext) == null ? void 0 : _g.originalCategory) {
+        const verifiedCategory = (_h = aiGeneratedContent.verifiedCategory) == null ? void 0 : _h.toLowerCase();
+        const requiredCategory = clientInput.quizContext.originalCategory.toLowerCase();
+        if (verifiedCategory && verifiedCategory !== requiredCategory) {
+          throw new Error(`Category mismatch: Required ${requiredCategory}, got ${verifiedCategory}`);
+        }
+      }
       const completeQuestion = {
         id: generateUniqueId("tf_ai_"),
         questionType: "true_false",
@@ -1142,164 +1596,1126 @@ Return only the JSON response.`;
         correctAnswer: aiGeneratedContent.correctAnswer,
         explanation: aiGeneratedContent.explanation,
         points: aiGeneratedContent.points,
-        topic: aiGeneratedContent.topic || clientInput.topic,
-        difficulty: aiGeneratedContent.difficulty || clientInput.difficulty,
-        contextCode: clientInput.contextDescription ? clientInput.selectedContextId : void 0
+        topic: aiGeneratedContent.topic || ((_i = clientInput.quizContext) == null ? void 0 : _i.originalTopic),
+        difficulty: clientInput.difficulty,
+        contextCode: (_j = clientInput.quizContext) == null ? void 0 : _j.plannedContextId,
+        bloomLevel: (_k = clientInput.quizContext) == null ? void 0 : _k.plannedBloomLevel,
+        learningObjective: (_l = clientInput.quizContext) == null ? void 0 : _l.originalLoId,
+        subject: (_m = clientInput.quizContext) == null ? void 0 : _m.originalSubject,
+        category: (_n = clientInput.quizContext) == null ? void 0 : _n.originalCategory,
+        imageUrl: clientInput.imageUrl
       };
-      try {
-        const validatedQuestion = TrueFalseQuestionZodSchema.parse(completeQuestion);
-        return { question: validatedQuestion };
-      } catch (validationError) {
-        console.error("Question validation failed:", validationError);
-        throw new Error(`Generated question failed validation: ${validationError}`);
+      const validatedQuestion = TrueFalseQuestionZodSchema.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)`);
+      if (attempt > 1) DebugLogger.logAttemptSummary(attemptResults);
+      return { question: validatedQuestion };
+    } catch (error) {
+      lastError = error;
+      const duration = Date.now() - startTime;
+      attemptResults.push({ success: false, duration, error: error.message, promptLength: promptText.length, promptHash });
+      const willRetry = attempt < MAX_RETRY_ATTEMPTS8;
+      DebugLogger.logRetryInfo(attempt, error, willRetry);
+      if (willRetry) {
+        console.log(`\u23F3 Retrying in ${RETRY_DELAY_MS8}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS8));
       }
-    } else {
-      throw new Error("AI did not return content for the True/False question.");
     }
-  } catch (error) {
-    console.error("Error generating True/False question:", error);
-    throw new Error(`Failed to generate True/False question: ${error.message}`);
   }
+  DebugLogger.logAttemptSummary(attemptResults);
+  const errorMessage = `Failed to generate True/False question after ${MAX_RETRY_ATTEMPTS8} attempts. Last error: ${lastError == null ? void 0 : lastError.message}`;
+  console.error("\n\u274C Final Result: FAILED");
+  console.error(errorMessage);
+  return { error: errorMessage };
 }
-function extractJsonFromMarkdown9(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  return match ? match[1].trim() : text.trim();
-}
-var fullQuizSupportedQuestionTypesArray = [
-  "true_false",
-  "multiple_choice",
-  "multiple_response",
-  "short_answer",
-  "numeric",
-  "fill_in_the_blanks",
-  "sequence",
-  "matching"
-];
-var BloomLevelStringsEnum = z.enum(["remembering", "understanding", "applying"]);
-z.object({
-  language: z.string().optional().default("English").describe('The language for the quiz plan (e.g., "Vietnamese", "English").'),
-  // <-- ĐÃ THÊM
-  totalQuestions: z.number().int().min(1).max(50),
-  topics: z.array(z.object({
-    topic: z.string().min(1),
-    ratio: z.number().min(0).max(100)
-  })).min(1),
-  bloomLevels: z.array(z.object({
-    level: BloomLevelStringsEnum,
-    ratio: z.number().min(0).max(100)
-  })).min(1),
-  selectedContextIds: z.array(z.string()).optional(),
-  selectedQuestionTypes: z.array(z.enum(fullQuizSupportedQuestionTypesArray)).min(1)
-});
-var PlannedQuestionSchema = z.object({
-  plannedTopic: z.string().min(1).describe("The specific topic for this question."),
-  plannedQuestionType: z.enum(fullQuizSupportedQuestionTypesArray).describe("The specific question type chosen."),
-  plannedBloomLevel: BloomLevelStringsEnum.describe("The Bloom's level assigned.")
-});
-var GenerateQuizPlanOutputSchema = z.object({
-  quizPlan: z.array(PlannedQuestionSchema).describe("A detailed plan for each question in the quiz.")
-});
-async function generateQuizPlan(clientInput, apiKey) {
-  try {
-    const totalTopicRatio = clientInput.topics.reduce((sum, t) => sum + t.ratio, 0);
-    if (Math.abs(totalTopicRatio - 100) > 1) {
-      throw new Error(`Total topic ratio must be 100%. Current sum: ${totalTopicRatio.toFixed(1)}%`);
+
+// src/utils/jsonUtils.ts
+var JsonRepairEngine = class {
+  /**
+   * Attempts to repair unterminated strings in JSON.
+   * NOTE: This is a heuristic approach and may not be perfect for all cases.
+   */
+  static repairUnterminatedStrings(jsonStr) {
+    let repaired = jsonStr;
+    let inString = false;
+    let escaped = false;
+    let lastQuoteIndex = -1;
+    for (let i = 0; i < repaired.length; i++) {
+      const char = repaired[i];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === '"') {
+        inString = !inString;
+        if (inString) {
+          lastQuoteIndex = i;
+        }
+      }
     }
-    const totalBloomRatio = clientInput.bloomLevels.reduce((sum, b) => sum + b.ratio, 0);
-    if (Math.abs(totalBloomRatio - 100) > 1) {
-      throw new Error(`Total Bloom level ratio must be 100%. Current sum: ${totalBloomRatio.toFixed(1)}%`);
+    if (inString && lastQuoteIndex !== -1) {
+      const beforeUnterminated = repaired.substring(0, lastQuoteIndex + 1);
+      const afterUnterminated = repaired.substring(lastQuoteIndex + 1);
+      const breakPoints = [",", "}", "]", "\n"];
+      let breakIndex = -1;
+      for (let i = 0; i < afterUnterminated.length; i++) {
+        if (breakPoints.includes(afterUnterminated[i])) {
+          breakIndex = i;
+          break;
+        }
+      }
+      if (breakIndex !== -1) {
+        const stringContent = afterUnterminated.substring(0, breakIndex);
+        const remainder = afterUnterminated.substring(breakIndex);
+        const escapedContent = stringContent.replace(new RegExp('(?<!\\\\)"', "g"), '\\"');
+        repaired = beforeUnterminated + escapedContent + '"' + remainder;
+      } else {
+        const escapedContent = afterUnterminated.replace(new RegExp('(?<!\\\\)"', "g"), '\\"');
+        repaired = beforeUnterminated + escapedContent + '"';
+      }
     }
-    const ai = genkit({
-      plugins: [googleAI({ apiKey })],
-      model: gemini20Flash
+    return repaired;
+  }
+  // FIX: Replaced unsafe single quote replacement with a stateful parser.
+  /**
+   * Safely replaces single quotes with double quotes only for keys and string values,
+   * ignoring apostrophes inside already double-quoted strings.
+   */
+  static safelyFixQuotes(jsonStr) {
+    let result = "";
+    let inDoubleQuoteString = false;
+    let escaped = false;
+    for (let i = 0; i < jsonStr.length; i++) {
+      const char = jsonStr[i];
+      if (escaped) {
+        result += char;
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        result += char;
+        continue;
+      }
+      if (char === '"') {
+        inDoubleQuoteString = !inDoubleQuoteString;
+      }
+      if (char === "'" && !inDoubleQuoteString) {
+        result += '"';
+      } else {
+        result += char;
+      }
+    }
+    return result;
+  }
+  /**
+   * Fixes common JSON formatting issues using more robust methods.
+   */
+  static applyCommonFixes(jsonStr) {
+    let fixed = jsonStr;
+    fixed = this.safelyFixQuotes(fixed);
+    fixed = fixed.replace(/,\s*([}\]])/g, "$1");
+    fixed = fixed.replace(/("|}|\d|]|true|false|null)\s*\n\s*(")/g, "$1,\n$2");
+    fixed = fixed.replace(/"[\s\S]*?"/g, (match) => {
+      const content = match.substring(1, match.length - 1);
+      const fixedContent = content.replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+      return `"${fixedContent}"`;
     });
-    const topicsDistribution = clientInput.topics.map((t) => `- Topic: "${t.topic}", Ratio: ${t.ratio}%`).join("\n    ");
-    const bloomDistribution = clientInput.bloomLevels.map((b) => `- Level: "${b.level}", Ratio: ${b.ratio}%`).join("\n    ");
-    const allowedQuestionTypes = clientInput.selectedQuestionTypes.map((t) => `'${t}'`).join(", ");
-    const promptText = `You are an expert educational content planner. Your task is to generate a detailed plan for a quiz in ${clientInput.language}.
+    fixed = fixed.replace(/"(true|false|null)"/g, "$1");
+    return fixed;
+  }
+  /**
+   * Validates JSON by attempting to parse and providing detailed error info.
+   */
+  static validateAndGetError(jsonStr) {
+    try {
+      JSON.parse(jsonStr);
+      return { isValid: true };
+    } catch (error) {
+      const errorMessage = error.message || "";
+      const positionMatch = errorMessage.match(/position (\d+)/);
+      const position = positionMatch ? parseInt(positionMatch[1], 10) : void 0;
+      return {
+        isValid: false,
+        error: errorMessage,
+        position
+      };
+    }
+  }
+  /**
+   * Main repair function that attempts multiple strategies.
+   */
+  static repairJson(jsonStr) {
+    var _a;
+    let current = jsonStr.trim();
+    const maxAttempts = 5;
+    let lastError = "";
+    let lastPosition = -1;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const validation = this.validateAndGetError(current);
+      if (validation.isValid) {
+        return current;
+      }
+      console.warn(`JSON repair attempt ${attempt + 1}: ${validation.error}`);
+      if (validation.error === lastError && validation.position === lastPosition) {
+        console.error("Repair attempt stuck on the same error, aborting this strategy.");
+        if (validation.position) {
+          const truncated = current.substring(0, validation.position);
+          const openBraces = (truncated.match(/{/g) || []).length;
+          const closeBraces = (truncated.match(/}/g) || []).length;
+          const openBrackets = (truncated.match(/\[/g) || []).length;
+          const closeBrackets = (truncated.match(/\]/g) || []).length;
+          let repaired = truncated.replace(/,\s*$/, "");
+          for (let i = 0; i < openBrackets - closeBrackets; i++) repaired += "]";
+          for (let i = 0; i < openBraces - closeBraces; i++) repaired += "}";
+          current = repaired;
+          const finalValidation = this.validateAndGetError(current);
+          if (finalValidation.isValid) return current;
+        }
+        break;
+      }
+      lastError = validation.error || "";
+      lastPosition = validation.position;
+      if ((_a = validation.error) == null ? void 0 : _a.includes("Unterminated string")) {
+        current = this.repairUnterminatedStrings(current);
+      } else {
+        current = this.applyCommonFixes(current);
+      }
+    }
+    try {
+      let finalAttempt = this.applyCommonFixes(jsonStr.trim());
+      finalAttempt = this.repairUnterminatedStrings(finalAttempt);
+      JSON.parse(finalAttempt);
+      return finalAttempt;
+    } catch (e) {
+      throw new Error(`Unable to repair JSON after ${maxAttempts} attempts. Last known error: ${lastError}`);
+    }
+  }
+};
+function extractJsonFromMarkdown(text) {
+  if (!text) {
+    throw new Error("Input text is empty or null.");
+  }
+  const trimmedText = text.trim();
+  try {
+    JSON.parse(trimmedText);
+    return trimmedText;
+  } catch (e) {
+  }
+  const markdownPatterns = [
+    /```(?:json|JSON)\s*([\s\S]*?)\s*```/,
+    // ```json ... ```
+    /```\s*({[\s\S]*?}|\[[\s\S]*?\])\s*```/
+    // ``` { ... } ``` or ``` [ ... ] ```
+  ];
+  for (const pattern of markdownPatterns) {
+    const match = trimmedText.match(pattern);
+    if (match && match[1]) {
+      const content = match[1].trim();
+      try {
+        JSON.parse(content);
+        return content;
+      } catch (e) {
+        console.warn("JSON inside markdown block is invalid, attempting repair...");
+        try {
+          return JsonRepairEngine.repairJson(content);
+        } catch (repairError) {
+          console.warn(`Markdown block repair failed: ${repairError.message}. Trying other strategies...`);
+        }
+      }
+    }
+  }
+  const firstBrace = trimmedText.indexOf("{");
+  const firstBracket = trimmedText.indexOf("[");
+  let startIndex = -1;
+  if (firstBrace === -1 && firstBracket === -1) ; else if (firstBrace === -1) {
+    startIndex = firstBracket;
+  } else if (firstBracket === -1) {
+    startIndex = firstBrace;
+  } else {
+    startIndex = Math.min(firstBrace, firstBracket);
+  }
+  if (startIndex !== -1) {
+    const textToProcess = trimmedText.substring(startIndex);
+    let balance = 0;
+    let inString = false;
+    let escaped = false;
+    const startChar = textToProcess[0];
+    const endChar = startChar === "{" ? "}" : "]";
+    for (let i = 0; i < textToProcess.length; i++) {
+      const char = textToProcess[i];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === '"') {
+        inString = !inString;
+      }
+      if (!inString) {
+        if (char === startChar) balance++;
+        if (char === endChar) balance--;
+      }
+      if (balance === 0 && i > 0) {
+        const potentialJson = textToProcess.substring(0, i + 1);
+        try {
+          JSON.parse(potentialJson);
+          return potentialJson;
+        } catch (e) {
+          console.warn(`Balanced JSON segment is invalid, attempting repair...`);
+          try {
+            return JsonRepairEngine.repairJson(potentialJson);
+          } catch (repairError) {
+            console.warn(`Repair failed for balanced segment: ${repairError.message}`);
+          }
+        }
+        break;
+      }
+    }
+  }
+  console.warn("All extraction strategies failed, attempting to repair the entire input text as a last resort.");
+  try {
+    return JsonRepairEngine.repairJson(trimmedText);
+  } catch (finalError) {
+    throw new Error(`Unable to extract or repair valid JSON from AI response. Preview: "${trimmedText.substring(0, 100)}...". Final error: ${finalError.message}`);
+  }
+}
+var TopicWithMetadataSchema = z.object({
+  topic: z.string().min(1),
+  ratio: z.number().min(0).max(100),
+  originalLoId: z.string().optional(),
+  originalSubject: z.string().optional(),
+  originalCategory: z.string().optional(),
+  originalTopic: z.string().optional(),
+  commonMisconceptions: z.array(z.string()).optional()
+});
+var BloomLevelStringsEnum = z.enum(["remembering", "understanding", "applying", "analyzing", "evaluating", "creating"]);
+var fullQuizSupportedQuestionTypesArray = [
+  "true_false",
+  "multiple_choice",
+  "multiple_response",
+  "short_answer",
+  "numeric",
+  "fill_in_the_blanks",
+  "sequence",
+  "matching",
+  "drag_and_drop",
+  "coding"
+];
+z.object({
+  language: z.string().optional().default("English"),
+  totalQuestions: z.number().int().min(1).max(50),
+  numCodingQuestions: z.number().optional().default(0),
+  topics: z.array(TopicWithMetadataSchema).min(1),
+  bloomLevels: z.array(z.object({
+    level: BloomLevelStringsEnum,
+    ratio: z.number().min(0).max(100)
+  })).min(1),
+  selectedContextIds: z.array(z.string()).optional(),
+  selectedQuestionTypes: z.array(z.enum(fullQuizSupportedQuestionTypesArray)).min(1),
+  imageContexts: z.array(z.custom()).optional().describe("Library of available image contexts for the AI to use.")
+});
+var PlannedQuestionSchema = z.object({
+  plannedTopic: z.string().min(1).describe("The specific, assessable topic for this question."),
+  plannedQuestionType: z.enum(fullQuizSupportedQuestionTypesArray).describe("The specific question type chosen."),
+  plannedBloomLevel: BloomLevelStringsEnum.describe("The Bloom's level assigned."),
+  plannedContextId: z.string().optional().describe("The specific context ID chosen for this question."),
+  imageId: z.string().nullable().optional().describe("The ID of the image from the context library to be used for this question."),
+  targetMisconception: z.string().optional().describe("A specific common misconception this question should target."),
+  difficultyReason: z.string().optional().describe("Strategic explanation of difficulty choice and placement."),
+  topicSpecificity: z.enum(["broad", "focused", "specific"]).optional().describe("How specific the topic coverage should be."),
+  originalLoId: z.string().optional(),
+  originalSubject: z.string().optional(),
+  originalCategory: z.string().optional(),
+  originalTopic: z.string().optional()
+});
+var GenerateQuizPlanOutputSchema = z.object({
+  quizPlan: z.array(PlannedQuestionSchema).describe("A detailed plan for each question in the quiz."),
+  diversityMetrics: z.object({
+    questionTypeDistribution: z.record(z.number()).optional(),
+    bloomLevelDistribution: z.record(z.number()).optional(),
+    maxConsecutiveSameType: z.number().optional()
+  }).optional().describe("Metrics showing the diversity achieved in the plan."),
+  planningStrategy: z.object({
+    overallApproach: z.string().optional(),
+    keyDecisions: z.array(z.string()).optional()
+  }).optional()
+});
 
-IMPORTANT: Return the response as JSON with this EXACT format:
-{
-  "quizPlan": [
-    { "plannedTopic": "Specific Topic A", "plannedQuestionType": "multiple_choice", "plannedBloomLevel": "remembering" },
-    { "plannedTopic": "Specific Topic B", "plannedQuestionType": "true_false", "plannedBloomLevel": "understanding" }
-  ]
+// src/ai/flows/generate-quiz-plan.ts
+var QuizPlanLogger = class {
+  constructor() {
+    this.logs = [];
+    this.startTime = Date.now();
+  }
+  log(phase, data, duration) {
+    this.logs.push({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      phase,
+      data,
+      duration
+    });
+    if (duration !== void 0) {
+      console.log(`[${phase}] Completed in ${duration}ms:`, data);
+    } else {
+      console.log(`[${phase}]:`, data);
+    }
+  }
+  getLogs() {
+    return this.logs;
+  }
+  getTotalDuration() {
+    return Date.now() - this.startTime;
+  }
+};
+function generateQuestionTypeSelectionGuidance() {
+  return `
+QUESTION TYPE SELECTION BEST PRACTICES:
+
+**TRUE_FALSE (true_false)**
+- Best for: Binary concepts, fact verification, common misconceptions
+- Bloom levels: Primarily Remembering, Understanding
+- Use when: Testing definitive statements, clarifying misconceptions
+- Example: "Photosynthesis only occurs during daytime" (targets timing misconception)
+
+**MULTIPLE CHOICE (multiple_choice)**
+- Best for: Concept selection, process understanding, comparison
+- Bloom levels: All levels, especially Understanding and Applying
+- Use when: Testing conceptual understanding with clear alternatives
+- Example: "Which factor most affects enzyme activity?" (applying knowledge)
+
+**MULTIPLE RESPONSE (multiple_response)**
+- Best for: Identifying multiple correct factors, comprehensive understanding
+- Bloom levels: Understanding, Analyzing, Evaluating
+- Use when: Multiple correct answers exist, testing thorough knowledge
+- Example: "Select all factors that influence plant growth" (analyzing components)
+
+**FILL IN THE BLANKS (fill_in_the_blanks)**
+- Best for: Key terminology, formulas, specific facts
+- Bloom levels: Remembering, Understanding
+- Use when: Testing precise recall of important terms/concepts
+- Example: "The process of _____ converts light energy to chemical energy"
+
+**NUMERIC (numeric)**
+- Best for: Calculations, quantitative problems, formula application
+- Bloom levels: Applying, Analyzing
+- Use when: Mathematical computations are required
+- Example: "Calculate the molarity of a 2L solution containing 0.5 moles of NaCl"
+
+**MATCHING (matching)**
+- Best for: Connecting related concepts, terminology pairs
+- Bloom levels: Remembering, Understanding
+- Use when: Testing relationships between terms and definitions
+- Example: Match organelles with their functions
+
+**SEQUENCE (sequence)**
+- Best for: Process steps, chronological order, procedural knowledge
+- Bloom levels: Understanding, Applying, Analyzing
+- Use when: Order or sequence is critical to understanding
+- Example: "Arrange the steps of mitosis in correct order"
+
+**DRAG AND DROP (drag_and_drop)**
+- Best for: Categorization, classification, spatial relationships
+- Bloom levels: Understanding, Applying, Analyzing
+- Use when: Grouping or organizing information is key
+- Example: "Classify these compounds as acids, bases, or neutral"
+
+**SHORT ANSWER (short_answer)**
+- Best for: Explanations, definitions, problem-solving steps
+- Bloom levels: Understanding, Applying, Analyzing, Evaluating, Creating
+- Use when: Requiring explanatory responses, open-ended thinking
+- Example: "Explain why enzymes are specific to certain substrates"
+
+**CODING (coding)**
+- Best for: Programming problems, algorithm implementation
+- Bloom levels: Applying, Analyzing, Evaluating, Creating
+- Use when: Technical implementation or code analysis is required
+- Example: "Write a function to calculate factorial recursively"
+`;
+}
+function generateAdvancedBloomGuidance() {
+  return `
+ADVANCED BLOOM'S TAXONOMY & QUESTION TYPE OPTIMIZATION:
+
+**REMEMBERING (Knowledge Recall)**
+- Primary types: true_false, fill_in_the_blanks, matching
+- Secondary types: multiple_choice (simple recall)
+- Focus: Facts, terms, basic concepts, definitions
+- Misconception addressing: Use true_false to clarify common confusions
+
+**UNDERSTANDING (Comprehension)**
+- Primary types: multiple_choice, short_answer, matching
+- Secondary types: multiple_response, sequence
+- Focus: Explanations, interpretations, examples, classifications
+- Best for: "Explain why...", "What does this mean...", "Give an example..."
+
+**APPLYING (Using Knowledge)**
+- Primary types: numeric, short_answer, sequence, coding
+- Secondary types: multiple_choice, drag_and_drop
+- Focus: Problem-solving, implementing procedures, using methods
+- Best for: Calculations, step-by-step processes, practical applications
+
+**ANALYZING (Breaking Down Information)**
+- Primary types: multiple_response, short_answer, sequence, coding
+- Secondary types: drag_and_drop, multiple_choice
+- Focus: Identifying components, relationships, cause-effect
+- Best for: "What are the factors...", "How do these relate...", "Break down..."
+
+**EVALUATING (Making Judgments)**
+- Primary types: short_answer, multiple_response, coding
+- Secondary types: multiple_choice (with justification)
+- Focus: Critiquing, judging, comparing alternatives, decision-making
+- Best for: "Which is better and why...", "Evaluate the approach...", "Critique..."
+
+**CREATING (Producing New Work)**
+- Primary types: short_answer, coding, sequence
+- Secondary types: drag_and_drop (design tasks)
+- Focus: Designing, planning, producing, constructing
+- Best for: "Design a solution...", "Create a plan...", "Develop a strategy..."
+`;
 }
+function generateDiversityRules() {
+  return `
+ENHANCED DIVERSITY & QUALITY ASSURANCE RULES:
+
+**Question Type Distribution Strategy:**
+1. Never place more than 3 consecutive questions of the same type
+2. Distribute question types based on their cognitive complexity
+3. For quizzes with 10+ questions, use at least 4 different question types
+4. For quizzes with 20+ questions, use at least 6 different question types
+5. Balance quick-answer types (true_false, multiple_choice) with deeper types (short_answer, coding)
+
+**Intelligent Difficulty Progression:**
+1. Opening (20%): Start with confidence-building questions (Remembering/Understanding)
+2. Building (40%): Gradually increase complexity (Understanding/Applying)
+3. Peak (30%): Most challenging questions (Analyzing/Evaluating/Creating)
+4. Closing (10%): Moderate challenge to end positively
 
-Constraints and Guidelines:
-1.  **Total Questions**: The output 'quizPlan' array must contain exactly ${clientInput.totalQuestions} elements.
-2.  **Topic Distribution**: Distribute the questions across the following topics according to their specified ratios. Match these ratios as closely as possible.
+**Misconception-Driven Planning:**
+- When common misconceptions are provided, prioritize question types that can effectively address them
+- Use true_false for binary misconceptions
+- Use multiple_choice for concept selection misconceptions
+- Use short_answer for complex misconceptions requiring explanation
+
+**Contextual Intelligence:**
+- Programming/Technical topics: Favor coding, numeric, short_answer
+- Process-oriented topics: Favor sequence, short_answer, drag_and_drop
+- Conceptual topics: Favor multiple_choice, multiple_response, true_false
+- Factual topics: Favor fill_in_the_blanks, matching, true_false
+`;
+}
+async function generateQuizPlan(clientInput, apiKey, imageContexts = []) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+  const logger = new QuizPlanLogger();
+  try {
+    logger.log("VALIDATION_START", {
+      totalQuestions: clientInput.totalQuestions,
+      availableTypes: clientInput.selectedQuestionTypes,
+      topicCount: clientInput.topics.length,
+      bloomLevelCount: clientInput.bloomLevels.length
+    });
+    const totalTopicRatio = clientInput.topics.reduce((sum, t) => sum + t.ratio, 0);
+    if (Math.abs(totalTopicRatio - 100) > 1) {
+      throw new Error(`Total topic ratio must be 100%. Current sum: ${totalTopicRatio.toFixed(1)}%`);
+    }
+    const totalBloomRatio = clientInput.bloomLevels.reduce((sum, b) => sum + b.ratio, 0);
+    if (Math.abs(totalBloomRatio - 100) > 1) {
+      throw new Error(`Total Bloom level ratio must be 100%. Current sum: ${totalBloomRatio.toFixed(1)}%`);
+    }
+    logger.log("VALIDATION_SUCCESS", {
+      topicRatioSum: totalTopicRatio,
+      bloomRatioSum: totalBloomRatio
+    });
+    const aiStartTime = Date.now();
+    const ai = new GoogleGenAI({
+      apiKey
+    });
+    const model = "gemini-2.5-pro";
+    const config = {
+      temperature: 0.8,
+      thinkingConfig: {
+        thinkingBudget: 4096
+      },
+      responseMimeType: "application/json"
+    };
+    logger.log("AI_INITIALIZATION", { model }, Date.now() - aiStartTime);
+    const { language, totalQuestions, numCodingQuestions = 0 } = clientInput;
+    const promptStartTime = Date.now();
+    const topicsDistribution = clientInput.topics.map((t) => {
+      let topicString = `- Topic Context: "${t.topic}", LoId: "${t.originalLoId || "nil"}", Subject: "${t.originalSubject || "nil"}", Category: "${t.originalCategory || "nil"}", Topic: "${t.originalTopic || "nil"}", Ratio: ${t.ratio}%`;
+      if (t.commonMisconceptions && t.commonMisconceptions.length > 0) {
+        topicString += `
+    - Common Misconceptions: [${t.commonMisconceptions.join(", ")}]`;
+      }
+      return topicString;
+    }).join("\n    ");
+    const bloomDistribution = clientInput.bloomLevels.map(
+      (b) => `- Level: "${b.level}", Ratio: ${b.ratio}%`
+    ).join("\n    ");
+    let questionTypesForPrompt = [...clientInput.selectedQuestionTypes];
+    if (numCodingQuestions === 0) {
+      questionTypesForPrompt = questionTypesForPrompt.filter(
+        (type) => type !== "short_answer" && type !== "coding"
+      );
+    }
+    const allowedQuestionTypes = questionTypesForPrompt.map((t) => `'${t}'`).join(", ");
+    const codingRequirement = numCodingQuestions > 0 ? `
+**CRITICAL CODING REQUIREMENT**: Exactly ${numCodingQuestions} questions in the plan MUST be of type 'coding'. These should typically be at 'applying' or higher Bloom levels and focus on implementation, debugging, or algorithm design.` : "";
+    const imageContextSection = imageContexts && imageContexts.length > 0 ? `
+## AVAILABLE IMAGE CONTEXT LIBRARY
+You have access to a library of pre-described images. When planning a question, if its subject, category, and topic match an image in this library AND the image's description is relevant to the planned question's topic, you MUST include the corresponding \`imageId\` in your output. Otherwise, leave the \`imageId\` field null or omit it.
+
+\`\`\`json
+${JSON.stringify(imageContexts.map((img) => ({ imageId: img.id, subject: img.subject, category: img.category, topic: img.topic, description: img.detailedDescription })), null, 2)}
+\`\`\`
+` : "";
+    const enhancedPromptText = `You are an elite educational assessment architect with expertise in cognitive science and adaptive learning. Your mission is to create a strategically optimized quiz plan that maximizes learning effectiveness.
+
+${generateQuestionTypeSelectionGuidance()}
+
+${generateAdvancedBloomGuidance()}
+
+${generateDiversityRules()}
+
+## COMPREHENSIVE QUIZ REQUIREMENTS:
+
+**Target Language**: ${language}
+**Total Questions**: ${totalQuestions}${codingRequirement}
+
+**Topic Distribution & Learning Context** (follow precisely):
     ${topicsDistribution}
-3.  **Bloom Level Distribution**: Distribute the questions across the following Bloom's Taxonomy levels according to their specified ratios.
+
+**Cognitive Complexity Distribution** (follow precisely):
     ${bloomDistribution}
-4.  **Allowed Question Types**: For each planned question, 'plannedQuestionType' must be one of these types: ${allowedQuestionTypes}. Use a variety of these types.
-5.  **Topic Specificity**: The 'plannedTopic' for each question should be a specific sub-topic or aspect related to one of the main topics provided, and must be in ${clientInput.language}.
 
-Carefully calculate the number of questions for each topic and Bloom level based on the total number of questions and the provided ratios. If ratios lead to fractional questions, round to the nearest whole number while ensuring the total number of questions remains exactly ${clientInput.totalQuestions}.
-The final 'quizPlan' array must have exactly ${clientInput.totalQuestions} elements.
+**Available Question Arsenal**: ${allowedQuestionTypes}
 
-Return only the JSON response.`;
-    const response = await ai.generate(promptText);
-    const rawText = response.text;
-    const jsonText = extractJsonFromMarkdown9(rawText);
-    console.log("AI Response:", jsonText);
-    const aiGeneratedContent = JSON.parse(jsonText);
-    if (!aiGeneratedContent || !aiGeneratedContent.quizPlan) {
-      throw new Error("AI did not return a valid quiz plan structure.");
+**Image Resources**: ${imageContextSection} 
+
+## STRATEGIC PLANNING METHODOLOGY:
+
+1. **Misconception Analysis**: If common misconceptions are provided, design questions specifically to address and correct them
+2. **Question Type Intelligence**: Select question types based on the cognitive demands and content nature
+3. **Difficulty Orchestration**: Create a learning journey that builds confidence while challenging appropriately
+4. **Diversity Optimization**: Ensure variety prevents monotony and maintains engagement
+5. **Context Sensitivity**: Match question types to topic characteristics (technical, conceptual, procedural)
+6. **Image Context Integration**: Intelligently associate questions with relevant images from the provided library to enhance contextual understanding.
+
+## ENHANCED OUTPUT FORMAT:
+
+Return ONLY a JSON object with this EXACT structure:
+
+\`\`\`json
+{
+  "quizPlan": [
+   {
+      "plannedTopic": "Specific, assessable topic derived from provided context",
+      "plannedQuestionType": "question_type_from_allowed_list",
+      "plannedBloomLevel": "bloom_level_from_requirements",
+      "plannedContextId": "THEO_ABS",
+      "imageId": "imgctx_12345abcde", // or null
+      "targetMisconception": "Specific misconception this question addresses (or 'none' if not applicable)",
+      "difficultyReason": "Strategic explanation of difficulty choice and placement",
+      "topicSpecificity": "broad|focused|specific",
+      "originalLoId": "corresponding_LoId_from_input",
+      "originalSubject": "corresponding_Subject_from_input",
+      "originalCategory": "corresponding_Category_from_input",
+      "originalTopic": "corresponding_Topic_from_input"
+    }
+  ],
+  "diversityMetrics": {
+    "questionTypeDistribution": {"type1": count1, "type2": count2},
+    "bloomLevelDistribution": {"level1": count1, "level2": count2},
+    "maxConsecutiveSameType": number,
+    "difficultyProgression": "description of how difficulty progresses",
+    "misconceptionCoverage": number_of_misconceptions_addressed
+  },
+  "planningStrategy": {
+    "overallApproach": "Brief description of the strategic approach taken",
+    "keyDecisions": ["Major decision 1", "Major decision 2", "Major decision 3"]
+  }
+}
+\`\`\`
+
+Execute this plan with pedagogical precision. The quiz should feel like a carefully crafted learning journey that challenges and educates simultaneously.`;
+    logger.log("PROMPT_PREPARATION", {
+      promptLength: enhancedPromptText.length,
+      topicCount: clientInput.topics.length,
+      misconceptionCount: clientInput.topics.reduce((sum, t) => {
+        var _a2;
+        return sum + (((_a2 = t.commonMisconceptions) == null ? void 0 : _a2.length) || 0);
+      }, 0)
+    }, Date.now() - promptStartTime);
+    const generationStartTime = Date.now();
+    const contents = [
+      {
+        role: "user",
+        parts: [
+          {
+            text: enhancedPromptText
+          }
+        ]
+      }
+    ];
+    const aiResult = await ai.models.generateContent({
+      model,
+      config,
+      contents
+    });
+    const response = aiResult;
+    const generationDuration = Date.now() - generationStartTime;
+    logger.log("AI_GENERATION", {
+      responseLength: ((_f = (_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.text) == null ? void 0 : _f.length) || 0,
+      duration: generationDuration
+    }, generationDuration);
+    const processingStartTime = Date.now();
+    const rawText = ((_k = (_j = (_i = (_h = (_g = response.candidates) == null ? void 0 : _g[0]) == null ? void 0 : _h.content) == null ? void 0 : _i.parts) == null ? void 0 : _j[0]) == null ? void 0 : _k.text) || "";
+    let jsonText = rawText;
+    if (!rawText.trim().startsWith("{") && !rawText.trim().startsWith("[")) {
+      jsonText = extractJsonFromMarkdown(rawText);
     }
+    logger.log("JSON_EXTRACTION", {
+      rawTextLength: rawText.length,
+      extractedJsonLength: jsonText.length
+    });
+    const aiGeneratedContent = GenerateQuizPlanOutputSchema.parse(JSON.parse(jsonText));
+    logger.log("SCHEMA_VALIDATION", { success: true }, Date.now() - processingStartTime);
+    const validationStartTime = Date.now();
     if (aiGeneratedContent.quizPlan.length !== clientInput.totalQuestions) {
-      throw new Error(`AI planned for ${aiGeneratedContent.quizPlan.length} questions, but ${clientInput.totalQuestions} were requested. The plan must match the total number of questions.`);
+      throw new Error(`AI planned for ${aiGeneratedContent.quizPlan.length} questions, but ${clientInput.totalQuestions} were requested.`);
     }
+    const invalidTypes = [];
     aiGeneratedContent.quizPlan.forEach((item, index) => {
       if (!clientInput.selectedQuestionTypes.includes(item.plannedQuestionType)) {
-        throw new Error(`AI planned question ${index + 1} with a disallowed question type: '${item.plannedQuestionType}'`);
+        invalidTypes.push(`Question ${index + 1}: '${item.plannedQuestionType}'`);
       }
     });
-    try {
-      const validatedPlan = GenerateQuizPlanOutputSchema.parse(aiGeneratedContent);
-      return validatedPlan;
-    } catch (validationError) {
-      console.error("Quiz plan validation failed:", validationError);
-      throw new Error(`Generated quiz plan failed validation: ${validationError}`);
+    if (invalidTypes.length > 0) {
+      throw new Error(`Invalid question types found: ${invalidTypes.join(", ")}`);
     }
+    const codingQuestions = aiGeneratedContent.quizPlan.filter((q) => q.plannedQuestionType === "coding");
+    if (numCodingQuestions > 0 && codingQuestions.length !== numCodingQuestions) {
+      throw new Error(`Expected ${numCodingQuestions} coding questions, but got ${codingQuestions.length}`);
+    }
+    const diversityAnalysis = validateConsecutiveTypes(aiGeneratedContent.quizPlan);
+    logger.log("VALIDATION_COMPLETE", {
+      questionCount: aiGeneratedContent.quizPlan.length,
+      codingQuestionCount: codingQuestions.length,
+      maxConsecutiveType: diversityAnalysis.maxConsecutive,
+      questionTypeDistribution: ((_l = aiGeneratedContent.diversityMetrics) == null ? void 0 : _l.questionTypeDistribution) || {}
+    }, Date.now() - validationStartTime);
+    const finalResult = __spreadProps(__spreadValues({}, aiGeneratedContent), {
+      logs: logger.getLogs()
+    });
+    logger.log("GENERATION_COMPLETE", {
+      totalDuration: logger.getTotalDuration(),
+      success: true,
+      finalQuestionCount: finalResult.quizPlan.length
+    }, logger.getTotalDuration());
+    console.log("\n=== QUIZ PLAN GENERATION SUMMARY ===");
+    console.log(`\u2705 Successfully generated ${finalResult.quizPlan.length} questions`);
+    console.log(`\u23F1\uFE0F Total generation time: ${logger.getTotalDuration()}ms`);
+    console.log(`\u{1F3AF} Question types: ${Object.keys(((_m = finalResult.diversityMetrics) == null ? void 0 : _m.questionTypeDistribution) || {}).join(", ")}`);
+    console.log(`\u{1F9E0} Bloom levels: ${Object.keys(((_n = finalResult.diversityMetrics) == null ? void 0 : _n.bloomLevelDistribution) || {}).join(", ")}`);
+    if (numCodingQuestions > 0) {
+      console.log(`\u{1F4BB} Coding questions: ${codingQuestions.length}/${numCodingQuestions} required`);
+    }
+    console.log(JSON.stringify(finalResult));
+    console.log("=====================================\n");
+    return finalResult;
   } catch (error) {
-    console.error("Error generating Quiz Plan:", error);
+    logger.log("ERROR", {
+      message: error.message,
+      stack: error.stack,
+      totalDuration: logger.getTotalDuration()
+    });
+    console.error("\u274C Quiz Plan Generation Failed:", error.message);
+    console.error("\u{1F4CB} Full logs available in returned object");
     throw new Error(`Failed to generate Quiz Plan: ${error.message}`);
   }
 }
-var internalContextOptions = [
-  // ... (giữ nguyên mảng này)
-  { contextId: "THEO_ABS", contextDescription: "L\xFD thuy\u1EBFt/Tr\u1EEBu t\u01B0\u1EE3ng" },
-  { contextId: "SPEC_CASE", contextDescription: "V\xED d\u1EE5 C\u1EE5 th\u1EC3/Tr\u01B0\u1EDDng h\u1EE3p Ri\xEAng" },
-  { contextId: "NAT_OBS", contextDescription: "Hi\u1EC7n t\u01B0\u1EE3ng T\u1EF1 nhi\xEAn/Quan s\xE1t" },
-  { contextId: "TECH_ENG", contextDescription: "\u1EE8ng d\u1EE5ng C\xF4ng ngh\u1EC7/K\u1EF9 thu\u1EADt" },
-  { contextId: "EXP_INV", contextDescription: "Th\xED nghi\u1EC7m/\u0110i\u1EC1u tra Khoa h\u1ECDc" },
-  { contextId: "REAL_PROB", contextDescription: "V\u1EA5n \u0111\u1EC1 Th\u1EF1c t\u1EBF/X\xE3 h\u1ED9i/M\xF4i tr\u01B0\u1EDDng" },
-  { contextId: "DATA_MOD", contextDescription: "Di\u1EC5n gi\u1EA3i D\u1EEF li\u1EC7u/M\xF4 h\xECnh h\xF3a" },
-  { contextId: "HIST_SCI", contextDescription: "L\u1ECBch s\u1EED/Ph\xE1t tri\u1EC3n Khoa h\u1ECDc" },
-  { contextId: "INTERDISC", contextDescription: "Li\xEAn ng\xE0nh (Interdisciplinary)" },
-  { contextId: "HYPO_COMP", contextDescription: "Gi\u1EA3 \u0111\u1ECBnh/So s\xE1nh T\xECnh hu\u1ED1ng" }
+function validateConsecutiveTypes(quizPlan) {
+  var _a, _b;
+  let maxConsecutive = 1;
+  let maxType = ((_a = quizPlan[0]) == null ? void 0 : _a.plannedQuestionType) || "";
+  let maxStartIndex = 0;
+  let currentConsecutive = 1;
+  let currentType = ((_b = quizPlan[0]) == null ? void 0 : _b.plannedQuestionType) || "";
+  let currentStartIndex = 0;
+  for (let i = 1; i < quizPlan.length; i++) {
+    if (quizPlan[i].plannedQuestionType === currentType) {
+      currentConsecutive++;
+    } else {
+      if (currentConsecutive > maxConsecutive) {
+        maxConsecutive = currentConsecutive;
+        maxType = currentType;
+        maxStartIndex = currentStartIndex;
+      }
+      currentConsecutive = 1;
+      currentType = quizPlan[i].plannedQuestionType;
+      currentStartIndex = i;
+    }
+  }
+  if (currentConsecutive > maxConsecutive) {
+    maxConsecutive = currentConsecutive;
+    maxType = currentType;
+    maxStartIndex = currentStartIndex;
+  }
+  return {
+    maxConsecutive,
+    type: maxType,
+    startIndex: maxStartIndex
+  };
+}
+
+// src/services/TopicDataService.ts
+var TopicDataService = class {
+  /**
+   * Saves an array of LearningObjective objects to Local Storage, overwriting existing data.
+   * @param data The array of learning objectives to save.
+   */
+  static saveData(data) {
+    try {
+      if (typeof window === "undefined") return;
+      const serializedData = JSON.stringify(data);
+      localStorage.setItem(this.STORAGE_KEY, serializedData);
+    } catch (error) {
+      console.error("Error saving learning objectives to Local Storage:", error);
+    }
+  }
+  /**
+   * Merges a new set of learning objectives with the existing data in Local Storage.
+   * If an LO ID from newData already exists, it will be updated. Otherwise, it will be added.
+   * @param newData The array of new or updated learning objectives.
+   */
+  static mergeData(newData) {
+    const existingData = this.getData();
+    const loMap = new Map(existingData.map((lo) => [lo.loId, lo]));
+    newData.forEach((newLo) => {
+      loMap.set(newLo.loId, newLo);
+    });
+    const mergedData = Array.from(loMap.values());
+    this.saveData(mergedData);
+  }
+  /**
+   * Retrieves the array of LearningObjective objects from Local Storage.
+   * @returns An array of learning objectives, or an empty array if none are found or an error occurs.
+   */
+  static getData() {
+    try {
+      if (typeof window === "undefined") return [];
+      const storedData = localStorage.getItem(this.STORAGE_KEY);
+      return storedData ? JSON.parse(storedData) : [];
+    } catch (error) {
+      console.error("Error retrieving learning objectives from Local Storage:", error);
+      this.clearData();
+      return [];
+    }
+  }
+  /**
+   * Removes all learning objective data from Local Storage.
+   */
+  static clearData() {
+    try {
+      if (typeof window === "undefined") return;
+      localStorage.removeItem(this.STORAGE_KEY);
+    } catch (error) {
+      console.error("Error clearing learning objectives from Local Storage:", error);
+    }
+  }
+  /**
+   * Parses TSV content into an array of LearningObjective objects.
+   * @param tsvContent The raw string content from a .tsv file.
+   * @returns An object containing the successfully parsed data and any errors encountered.
+   */
+  static parseTSV(tsvContent) {
+    const lines = tsvContent.split("\n").filter((line) => line.trim() !== "");
+    if (lines.length < 2) {
+      return { data: [], errors: ["File is empty or contains only a header."] };
+    }
+    const headerLine = lines.shift();
+    const headers = headerLine.split("	").map((h) => h.trim());
+    if (headers.length !== this.EXPECTED_HEADERS.length || !this.EXPECTED_HEADERS.every((h, i) => h === headers[i])) {
+      const errorMsg = `Invalid TSV header. Expected: "${this.EXPECTED_HEADERS.join("	")}". Received: "${headers.join("	")}"`;
+      return { data: [], errors: [errorMsg] };
+    }
+    const data = [];
+    const errors = [];
+    lines.forEach((line, index) => {
+      const values = line.split("	").map((v) => v.trim());
+      if (values.length !== this.EXPECTED_HEADERS.length) {
+        errors.push(`Line ${index + 2}: Incorrect number of columns. Expected ${this.EXPECTED_HEADERS.length}, but got ${values.length}.`);
+        return;
+      }
+      const [
+        loId,
+        loDescription,
+        subject,
+        category,
+        topic,
+        keywordsStr,
+        grade,
+        stemElementsStr,
+        bloomLevelsStr
+      ] = values;
+      if (!loId || !subject || !category || !topic) {
+        errors.push(`Line ${index + 2}: Missing required fields (LO ID, Subject, Category, or Topic).`);
+        return;
+      }
+      const learningObjective = {
+        loId,
+        loDescription,
+        subject,
+        category,
+        topic,
+        keywords: keywordsStr.split(",").map((k) => k.trim()).filter(Boolean),
+        grade,
+        stemElements: stemElementsStr.split(",").map((s) => s.trim()).filter(Boolean),
+        bloomLevelsGuideline: bloomLevelsStr.split(",").map((b) => b.trim()).filter(Boolean)
+      };
+      data.push(learningObjective);
+    });
+    return { data, errors };
+  }
+  /**
+   * Gets a unique list of all subjects from the stored data.
+   * @returns An array of subject strings.
+   */
+  static getSubjects() {
+    const data = this.getData();
+    const subjects = data.map((item) => item.subject);
+    return [...new Set(subjects)].sort();
+  }
+  /**
+   * Gets a unique list of categories for a given subject.
+   * @param subject The subject to filter by.
+   * @returns An array of category strings.
+   */
+  static getCategoriesBySubject(subject) {
+    const data = this.getData();
+    const categories = data.filter((item) => item.subject === subject).map((item) => item.category);
+    return [...new Set(categories)].sort();
+  }
+  /**
+   * Gets a unique list of topics for a given category.
+   * @param category The category to filter by.
+   * @returns An array of topic strings.
+   */
+  static getTopicsByCategory(category) {
+    const data = this.getData();
+    const topics = data.filter((item) => item.category === category).map((item) => item.topic);
+    return [...new Set(topics)].sort();
+  }
+  /**
+   * Retrieves all LearningObjective details for a given list of topics.
+   * @param topics An array of topic strings to search for.
+   * @returns An array of matching LearningObjective objects.
+   */
+  static getLearningObjectivesByTopics(topics) {
+    const data = this.getData();
+    const topicSet = new Set(topics);
+    return data.filter((item) => topicSet.has(item.topic));
+  }
+};
+TopicDataService.STORAGE_KEY = "interactive_quiz_kit_learning_objectives";
+TopicDataService.EXPECTED_HEADERS = [
+  "LO ID",
+  "LO Description",
+  "Subject",
+  "Category",
+  "Topic",
+  "Keywords",
+  "Grade",
+  "STEM Element(s)",
+  "Bloom\u2019s Level(s) Guideline"
 ];
-var calculateCombinedDifficulty = (contextId, bloomLevel, qType, generalCustomContextInput) => {
-  let contextScore = 1;
-  const selectedContext = contextId ? internalContextOptions.find((c) => c.contextId === contextId) : void 0;
-  if (selectedContext) {
-    if (["THEO_ABS", "HIST_SCI"].includes(selectedContext.contextId)) contextScore = 1;
-    else if (["SPEC_CASE", "NAT_OBS", "DATA_MOD", "INTERDISC", "HYPO_COMP"].includes(selectedContext.contextId)) contextScore = 2;
-    else if (["TECH_ENG", "EXP_INV", "REAL_PROB"].includes(selectedContext.contextId)) contextScore = 3;
-  } else if (generalCustomContextInput == null ? void 0 : generalCustomContextInput.trim()) {
-    contextScore = 2;
+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()),
+    expectedOutput: z.any().describe("The expected output for this test case - REQUIRED"),
+    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 == null ? void 0 : 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.
+
+` : "";
+  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 == null ? void 0 : quizContext.loDescription) && `**Learning Objective:** ${quizContext.loDescription}`,
+    imageContextInstruction,
+    (quizContext == null ? void 0 : quizContext.plannedBloomLevel) && `**Cognitive Level (Bloom's):** ${quizContext.plannedBloomLevel}`,
+    (quizContext == null ? void 0 : 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.
+
+## CRITICAL CONTEXT FOR THIS QUESTION
+${contextStrings}
+
+## Task: Generate the Question
+### Input Parameters
+- **Topic for Question:** ${(quizContext == null ? void 0 : 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) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  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, __spreadProps(__spreadValues({}, 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 = ((_e = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) == null ? void 0 : _d[0]) == null ? void 0 : _e.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) => {
+        if (tc.expectedOutput === void 0) {
+          throw new Error("A test case from AI is missing the required 'expectedOutput' field.");
+        }
+        return {
+          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,
+        // FIXED: Correct field name
+        functionSignature: aiGeneratedContent.functionSignature,
+        solutionCode: aiGeneratedContent.solutionCode,
+        testCases,
+        points: 25,
+        topic: (_f = clientInput.quizContext) == null ? void 0 : _f.originalTopic,
+        difficulty: clientInput.difficulty,
+        contextCode: (_g = clientInput.quizContext) == null ? void 0 : _g.plannedContextId,
+        bloomLevel: (_h = clientInput.quizContext) == null ? void 0 : _h.plannedBloomLevel,
+        learningObjective: (_i = clientInput.quizContext) == null ? void 0 : _i.originalLoId,
+        subject: (_j = clientInput.quizContext) == null ? void 0 : _j.originalSubject,
+        category: (_k = clientInput.quizContext) == null ? void 0 : _k.originalCategory,
+        imageUrl: clientInput.imageUrl
+      };
+      const validatedQuestion = 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: 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_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 == null ? void 0 : 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;
+var RETRY_DELAY_MS10 = 2e3;
+var delay = (ms) => new Promise((res) => setTimeout(res, ms));
+var calculateCombinedDifficulty = (plannedQ) => {
+  const { plannedBloomLevel, plannedQuestionType, plannedContextId } = plannedQ;
+  let contextScore = 1;
+  if (["SPEC_CASE", "NAT_OBS", "DATA_MOD", "INTERDISC", "HYPO_COMP"].includes(plannedContextId || "")) contextScore = 2;
+  else if (["TECH_ENG", "EXP_INV", "REAL_PROB"].includes(plannedContextId || "")) contextScore = 3;
   let bloomScore = 1;
-  if (bloomLevel === "understanding") bloomScore = 2;
-  else if (bloomLevel === "applying") bloomScore = 3;
+  if (plannedBloomLevel === "understanding") bloomScore = 2;
+  else if (plannedBloomLevel === "applying") bloomScore = 3;
+  else if (["analyzing", "evaluating", "creating"].includes(plannedBloomLevel)) bloomScore = 4;
   let questionTypeScore = 1;
-  switch (qType) {
-    case "true_false":
-    case "multiple_choice":
-    case "short_answer":
-      questionTypeScore = 1;
-      break;
+  switch (plannedQuestionType) {
     case "matching":
     case "fill_in_the_blanks":
     case "numeric":
@@ -1308,131 +2724,853 @@ var calculateCombinedDifficulty = (contextId, bloomLevel, qType, generalCustomCo
     case "sequence":
     case "multiple_response":
     case "drag_and_drop":
+    case "coding":
       questionTypeScore = 3;
       break;
-    default:
-      questionTypeScore = 1;
   }
   const totalScore = bloomScore + contextScore + questionTypeScore;
   if (totalScore <= 4) return "easy";
-  if (totalScore <= 6) return "medium";
+  if (totalScore <= 7) return "medium";
   return "hard";
 };
-var PlannedQuestionSchema2 = z.object({
-  plannedTopic: z.string().min(1),
-  plannedQuestionType: z.string(),
-  // Giữ dạng string để linh hoạt, sẽ kiểm tra trong logic
-  plannedBloomLevel: z.enum(["remembering", "understanding", "applying"]),
-  plannedContextId: z.string().optional()
-});
-z.object({
-  quizPlan: z.array(PlannedQuestionSchema2).min(1),
-  language: z.string().optional().default("English").describe("The language for the generated questions."),
-  // <-- ĐÃ THÊM
-  selectedContextIds: z.array(z.string()).optional(),
-  customContextInput: z.string().optional()
-});
-var GenerationErrorSchema = z.object({
-  plannedQuestionIndex: z.number(),
-  plannedTopic: z.string(),
-  plannedQuestionType: z.string(),
-  error: z.string()
-});
-z.object({
-  generatedQuestions: z.array(z.any()),
-  // z.any() là thực tế vì union của tất cả các loại câu hỏi rất phức tạp
-  errors: z.array(GenerationErrorSchema).optional()
-});
 async function generateQuestionsFromQuizPlan(clientInput, apiKey) {
   var _a, _b;
-  const { quizPlan, selectedContextIds, customContextInput, language } = clientInput;
+  const { quizPlan, language, imageContexts } = clientInput;
   const generatedQuestions = [];
   const errors = [];
+  const allLearningObjectives = TopicDataService.getData();
   for (let i = 0; i < quizPlan.length; i++) {
     const plannedQ = quizPlan[i];
-    let generationError = null;
-    try {
-      let contextDescriptionForAI;
-      let contextIdForDifficultyCalc = plannedQ.plannedContextId;
-      if (plannedQ.plannedContextId && plannedQ.plannedContextId !== "__custom__") {
-        contextDescriptionForAI = (_a = internalContextOptions.find((c) => c.contextId === plannedQ.plannedContextId)) == null ? void 0 : _a.contextDescription;
-      } else if (plannedQ.plannedContextId === "__custom__") {
-        contextDescriptionForAI = customContextInput == null ? void 0 : customContextInput.trim();
-      } else if ((selectedContextIds == null ? void 0 : selectedContextIds[0]) && selectedContextIds[0] !== "__custom__") {
-        contextDescriptionForAI = (_b = internalContextOptions.find((c) => c.contextId === selectedContextIds[0])) == null ? void 0 : _b.contextDescription;
-        if (!contextIdForDifficultyCalc) contextIdForDifficultyCalc = selectedContextIds[0];
-      } else if (customContextInput == null ? void 0 : customContextInput.trim()) {
-        contextDescriptionForAI = customContextInput.trim();
-        if (!contextIdForDifficultyCalc) contextIdForDifficultyCalc = "__custom__";
-      }
-      const difficultyForAI = calculateCombinedDifficulty(
-        contextIdForDifficultyCalc,
-        plannedQ.plannedBloomLevel,
-        plannedQ.plannedQuestionType,
-        contextDescriptionForAI
-      );
-      const baseClientInput = {
-        topic: plannedQ.plannedTopic,
-        language,
-        // <-- TRUYỀN `language` VÀO
-        difficulty: difficultyForAI,
-        contextDescription: contextDescriptionForAI,
-        selectedContextId: plannedQ.plannedContextId || contextIdForDifficultyCalc
-      };
-      let result = {};
-      switch (plannedQ.plannedQuestionType) {
-        case "true_false":
-          result = await generateTrueFalseQuestion(baseClientInput, apiKey);
-          break;
-        case "multiple_choice":
-          result = await generateMCQQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfOptions: 4 }), apiKey);
-          break;
-        case "multiple_response":
-          result = await generateMRQQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfOptions: 5, minCorrectAnswers: 2, maxCorrectAnswers: 3 }), apiKey);
-          break;
-        case "short_answer":
-          result = await generateShortAnswerQuestion(__spreadProps(__spreadValues({}, baseClientInput), { isCaseSensitive: false }), apiKey);
-          break;
-        case "numeric":
-          result = await generateNumericQuestion(__spreadProps(__spreadValues({}, baseClientInput), { allowDecimals: true }), apiKey);
-          break;
-        case "fill_in_the_blanks":
-          result = await generateFillInTheBlanksQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfBlanks: 2, isCaseSensitive: false }), apiKey);
-          break;
-        case "sequence":
-          result = await generateSequenceQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfItems: 4 }), apiKey);
-          break;
-        case "matching":
-          result = await generateMatchingQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfPairs: 4, shuffleOptions: true }), apiKey);
+    let questionGenerated = false;
+    let lastError = null;
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+      try {
+        const fullLO = plannedQ.originalLoId ? allLearningObjectives.find((lo) => lo.loId === plannedQ.originalLoId) : null;
+        const quizContext = {
+          plannedTopic: plannedQ.plannedTopic,
+          plannedQuestionType: plannedQ.plannedQuestionType,
+          plannedBloomLevel: plannedQ.plannedBloomLevel,
+          plannedContextId: plannedQ.plannedContextId,
+          targetMisconception: plannedQ.targetMisconception,
+          difficultyReason: plannedQ.difficultyReason,
+          topicSpecificity: plannedQ.topicSpecificity,
+          originalLoId: plannedQ.originalLoId,
+          originalSubject: plannedQ.originalSubject,
+          originalCategory: plannedQ.originalCategory,
+          originalTopic: plannedQ.originalTopic,
+          loDescription: (fullLO == null ? void 0 : fullLO.loDescription) || plannedQ.plannedTopic
+        };
+        const imageUrl = plannedQ.imageId && imageContexts ? (_a = imageContexts.find((ctx) => ctx.id === plannedQ.imageId)) == null ? void 0 : _a.imageUrl : void 0;
+        const baseClientInput = {
+          language,
+          difficulty: calculateCombinedDifficulty(plannedQ),
+          quizContext,
+          imageUrl
+        };
+        let result = {};
+        switch (plannedQ.plannedQuestionType) {
+          case "true_false":
+            result = await generateTrueFalseQuestion(baseClientInput, apiKey);
+            break;
+          case "multiple_choice":
+            result = await generateMCQQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfOptions: 4 }), apiKey);
+            break;
+          case "multiple_response":
+            result = await generateMRQQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfOptions: 5, minCorrectAnswers: 2, maxCorrectAnswers: 3 }), apiKey);
+            break;
+          case "short_answer":
+            result = await generateShortAnswerQuestion(__spreadProps(__spreadValues({}, baseClientInput), { isCaseSensitive: false }), apiKey);
+            break;
+          case "numeric":
+            result = await generateNumericQuestion(__spreadProps(__spreadValues({}, baseClientInput), { allowDecimals: true, tolerance: 0 }), apiKey);
+            break;
+          case "fill_in_the_blanks":
+            result = await generateFillInTheBlanksQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfBlanks: 2, isCaseSensitive: false }), apiKey);
+            break;
+          case "sequence":
+            result = await generateSequenceQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfItems: 4 }), apiKey);
+            break;
+          case "matching":
+            result = await generateMatchingQuestion(__spreadProps(__spreadValues({}, baseClientInput), { numberOfPairs: 4, shuffleOptions: true }), apiKey);
+            break;
+          case "coding": {
+            const subject = ((_b = plannedQ.originalSubject) == null ? void 0 : _b.toLowerCase()) || "";
+            let codingLanguage = "javascript";
+            if (subject.includes("swift")) codingLanguage = "swift";
+            else if (subject.includes("python")) codingLanguage = "python";
+            result = await generateCodingQuestion(__spreadProps(__spreadValues({}, baseClientInput), {
+              codingLanguage,
+              displayLanguage: language || "English"
+            }), apiKey);
+            break;
+          }
+          default:
+            throw new Error(`Question type "${plannedQ.plannedQuestionType}" is not supported for automated generation.`);
+        }
+        if (result.error) {
+          throw new Error(result.error);
+        }
+        if (result.question) {
+          const question = result.question;
+          question.learningObjective = plannedQ.originalLoId;
+          question.subject = plannedQ.originalSubject;
+          question.category = plannedQ.originalCategory;
+          question.topic = plannedQ.originalTopic;
+          question.bloomLevel = plannedQ.plannedBloomLevel;
+          if (question.points === void 0) question.points = 10;
+          generatedQuestions.push(question);
+          questionGenerated = true;
           break;
-        default:
-          generationError = `Question type "${plannedQ.plannedQuestionType}" is not supported for automated generation.`;
-      }
-      if (result.question) {
-        const question = result.question;
-        question.topic = plannedQ.plannedTopic;
-        question.bloomLevel = plannedQ.plannedBloomLevel;
-        question.difficulty = difficultyForAI;
-        question.contextCode = baseClientInput.selectedContextId;
-        if (question.points === void 0) question.points = 10;
-        generatedQuestions.push(question);
-      } else if (!generationError) {
-        generationError = `AI did not return a question object for type '${plannedQ.plannedQuestionType}'.`;
+        } else {
+          throw new Error(`AI did not return a question object for type '${plannedQ.plannedQuestionType}'.`);
+        }
+      } catch (e) {
+        lastError = e;
+        console.warn(`Attempt ${attempt} failed for question ${i + 1} (Topic: ${plannedQ.plannedTopic}): ${e.message}`);
+        if (attempt < MAX_ATTEMPTS) {
+          await delay(RETRY_DELAY_MS10);
+        }
       }
-    } catch (e) {
-      generationError = e.message || `An unknown error occurred.`;
     }
-    if (generationError) {
-      console.error(`Error generating question at index ${i} (Topic: ${plannedQ.plannedTopic}): ${generationError}`);
+    if (!questionGenerated && lastError) {
       errors.push({
         plannedQuestionIndex: i,
         plannedTopic: plannedQ.plannedTopic,
         plannedQuestionType: plannedQ.plannedQuestionType,
-        error: generationError
+        error: lastError.message || "Unknown error after all retries."
       });
     }
   }
   return { generatedQuestions, errors: errors.length > 0 ? errors : void 0 };
 }
+var QuestionResultForAISchema = z.object({
+  questionId: z.string(),
+  prompt: z.string(),
+  isCorrect: z.boolean(),
+  userAnswer: z.any().optional(),
+  correctAnswer: z.any().optional(),
+  evaluationDetails: z.array(z.custom()).optional().describe("Detailed results for each test case, for coding questions.")
+});
+z.object({
+  language: z.string().describe('The language for the generated review (e.g., "Vietnamese", "English").'),
+  questionResults: z.array(QuestionResultForAISchema).min(1)
+});
+var AIQuizReviewOutputSchema = z.object({
+  questionReviews: z.array(
+    z.object({
+      questionId: z.string().describe("The ID of the question being reviewed."),
+      explanation: z.string().describe("A detailed, personalized explanation for this question in Markdown format.")
+    })
+  ).describe("An array of reviews, one for each question."),
+  overallSummary: z.string().describe("A comprehensive summary of key concepts in Markdown format."),
+  relatedTopics: z.array(z.string()).describe("A list of suggested topics or keywords for further study.")
+});
+
+// src/ai/flows/generate-quiz-review.ts
+async function generateQuizReview(clientInput, apiKey) {
+  try {
+    const ai = genkit({
+      plugins: [googleAI({ apiKey })],
+      model: gemini20Flash
+    });
+    const resultsString = JSON.stringify(clientInput.questionResults, null, 2);
+    const promptText = `
+You are an expert educational tutor. Your task is to analyze a student's quiz results and provide a detailed, helpful review in ${clientInput.language}.
+
+**Here are the student's quiz results:**
+${resultsString}
+
+**Instructions:**
+1.  **Analyze Each Question:** For every question in the results, create a corresponding object in the "questionReviews" array. Match the "questionId".
+2.  **Write Personalized Explanations:** In the "explanation" for each question, provide a clear and encouraging explanation.
+    - **For standard questions:** Explain why the correct answer is right and, if the user was wrong, gently explain their misconception.
+    - **CRITICAL - For CODING questions (those with 'evaluationDetails'):**
+        - If the user was correct ('isCorrect': true), congratulate them and briefly praise their solution.
+        - If the user was incorrect, analyze the 'evaluationDetails'. Find the FIRST failed test case. Explain WHY their code failed that specific test case. For example: "Your code works for positive numbers, but it failed on the test case with an empty array. It seems you haven't handled that edge case."
+        - DO NOT just repeat the test case data. Provide a pedagogical explanation.
+3.  **Create an Overall Summary:** In "overallSummary", synthesize the main ideas from all questions into a cohesive review. Focus on reinforcing the main learning points, especially those related to questions the user answered incorrectly.
+4.  **Suggest Further Study:** In "relatedTopics", provide 2-3 specific keywords or topics for further study.
+5.  **Language and Formatting:** Ensure all generated text is in ${clientInput.language} and uses Markdown.
+
+**JSON OUTPUT FORMAT:**
+Return a single, valid JSON object with this EXACT format.
+
+\`\`\`json
+{
+  "questionReviews": [
+    {
+      "questionId": "some-question-id-1",
+      "explanation": "Your detailed explanation for the first question goes here."
+    }
+  ],
+  "overallSummary": "A comprehensive summary of the key concepts from the quiz.",
+  "relatedTopics": ["Keyword for further study 1", "Related Concept 2"]
+}
+\`\`\`
+
+Return only the valid JSON response.`;
+    const response = await ai.generate(promptText);
+    const rawText = response.text;
+    const jsonText = extractJsonFromMarkdown(rawText);
+    const aiGeneratedContent = JSON.parse(jsonText);
+    const validatedOutput = AIQuizReviewOutputSchema.parse(aiGeneratedContent);
+    return validatedOutput;
+  } catch (error) {
+    console.error("Error generating Quiz Review:", error);
+    if (error instanceof z.ZodError) {
+      throw new Error(`AI returned data in an unexpected format. Validation failed: ${error.message}`);
+    }
+    throw new Error(`Failed to generate Quiz Review: ${error.message}`);
+  }
+}
+z.object({
+  language: z.string(),
+  userName: z.string().optional(),
+  performanceByTopic: z.array(z.object({
+    name: z.string(),
+    averageScore: z.number()
+  })).optional(),
+  recentHistory: z.array(z.object({
+    quizTitle: z.string(),
+    percentage: z.number(),
+    topics: z.array(z.object({
+      subject: z.string(),
+      category: z.string(),
+      topic: z.string()
+    }))
+  })).optional(),
+  allAvailableTopics: z.array(z.object({
+    loId: z.string(),
+    subject: z.string(),
+    category: z.string(),
+    topic: z.string()
+  }))
+});
+var PracticeSuggestionOutputSchema = z.object({
+  suggestionText: z.string().describe("The personalized message from the AI tutor in Markdown format."),
+  suggestedTopics: z.array(z.object({
+    loId: z.string(),
+    topicName: z.string(),
+    reason: z.enum(["review", "explore"]),
+    suggestedDifficulty: z.enum(["Very Easy", "Easy", "Medium", "Hard", "Expert"])
+  }))
+});
+async function generatePracticeSuggestion(clientInput, apiKey) {
+  try {
+    const ai = genkit({
+      plugins: [googleAI({ apiKey })],
+      model: gemini20Flash
+    });
+    const { language, userName, performanceByTopic, recentHistory, allAvailableTopics } = clientInput;
+    const promptText = `
+You are a friendly and insightful AI Learning Coach. Your goal is to provide a personalized practice suggestion for a student named ${userName || "there"}.
+
+**Analyze the following student data:**
+
+1.  **Performance by Topic (Weaknesses):**
+    ${JSON.stringify(performanceByTopic, null, 2)}
+
+2.  **Recent Practice Sessions (Strengths & Recent Activity):**
+    ${JSON.stringify(recentHistory, null, 2)}
+
+3.  **All Available Topics in the Curriculum:**
+    ${JSON.stringify(allAvailableTopics.slice(0, 50), null, 2)}... (and more)
+
+**Your Task:**
+Based on the data, create a helpful and encouraging practice plan. Follow these steps in your reasoning:
+1.  **Identify Weaknesses:** Look at "Performance by Topic". Identify 1-2 topics with the lowest 'averageScore'. These are candidates for 'review'.
+2.  **Identify Strengths/Interests:** Look at "Recent Practice Sessions". Identify 1-2 topics the student has recently practiced and performed well on (e.g., score > 80%).
+3.  **Suggest Related Topics:** From the "All Available Topics" list, find 1-2 new topics that are in the same 'category' or 'subject' as the student's strengths. These are candidates for 'explore'.
+4.  **Suggest Difficulty:** For each suggested topic, determine an appropriate difficulty level ('Easy', 'Medium', or 'Hard').
+    - If the reason is 'review', suggest 'Easy' or 'Medium' to help them rebuild their foundation.
+    - If the reason is 'explore', suggest 'Medium' as a starting point for a new challenge.
+5.  **Synthesize a Plan:** Combine the topics for 'review' and 'explore' into a balanced suggestion.
+6.  **Write a Personalized Message:** In 'suggestionText', write a friendly message in ${language}. Explain WHY you are suggesting these topics and difficulties.
+
+**JSON OUTPUT FORMAT:**
+Return a single, valid JSON object in this exact format. All text must be in ${language}.
+
+{
+  "suggestionText": "Ch\xE0o ${userName || "b\u1EA1n"}, t\xF4i \u0111\xE3 xem qua k\u1EBFt qu\u1EA3 c\u1EE7a b\u1EA1n! \u0110\u1EC3 c\u1EE7ng c\u1ED1 ki\u1EBFn th\u1EE9c, ch\xFAng ta h\xE3y \xF4n l\u1EA1i ch\u1EE7 \u0111\u1EC1 [T\xEAn ch\u1EE7 \u0111\u1EC1 y\u1EBFu] \u1EDF m\u1EE9c \u0111\u1ED9 'Easy' nh\xE9. V\xEC b\u1EA1n \u0111\xE3 l\xE0m r\u1EA5t t\u1ED1t ph\u1EA7n [T\xEAn ch\u1EE7 \u0111\u1EC1 m\u1EA1nh], h\xE3y th\u1EED s\u1EE9c v\u1EDBi ch\u1EE7 \u0111\u1EC1 li\xEAn quan l\xE0 [T\xEAn ch\u1EE7 \u0111\u1EC1 kh\xE1m ph\xE1] \u1EDF m\u1EE9c \u0111\u1ED9 'Medium' xem sao!",
+  "suggestedTopics": [
+    { "loId": "some-lo-id-1", "topicName": "[T\xEAn ch\u1EE7 \u0111\u1EC1 y\u1EBFu]", "reason": "review", "suggestedDifficulty": "Easy" },
+    { "loId": "some-lo-id-2", "topicName": "[T\xEAn ch\u1EE7 \u0111\u1EC1 kh\xE1m ph\xE1]", "reason": "explore", "suggestedDifficulty": "Medium" }
+  ]
+}
+
+Return only the JSON response.`;
+    const response = await ai.generate(promptText);
+    const rawText = response.text;
+    const jsonText = extractJsonFromMarkdown(rawText);
+    const aiGeneratedContent = JSON.parse(jsonText);
+    const validatedOutput = PracticeSuggestionOutputSchema.parse(aiGeneratedContent);
+    return validatedOutput;
+  } catch (error) {
+    console.error("Error generating practice suggestion:", error);
+    if (error instanceof z.ZodError) {
+      throw new Error(`AI returned data in an unexpected format. Validation failed: ${error.message}`);
+    }
+    throw new Error(`Failed to generate practice suggestion: ${error.message}`);
+  }
+}
+z.object({
+  language: z.string().default("English"),
+  userName: z.string().optional(),
+  weeklyGoal: z.number().optional(),
+  unlockedAchievements: z.array(z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string(),
+    icon: z.string()
+  })),
+  stats: z.any(),
+  // Using z.any() for simplicity, as PracticeStats is complex and defined elsewhere.
+  history: z.array(z.any()),
+  // Using z.any() for simplicity.
+  startDate: z.string().describe("The start date for the analysis period in ISO format (YYYY-MM-DD)."),
+  endDate: z.string().describe("The end date for the analysis period in ISO format (YYYY-MM-DD)."),
+  allAvailableTopics: z.array(z.object({
+    loId: z.string(),
+    subject: z.string(),
+    category: z.string(),
+    topic: z.string()
+  })).describe("A complete list of all available topics for the AI to choose from.")
+});
+var RoadmapItemSchema = z.object({
+  day: z.string(),
+  topicName: z.string(),
+  reason: z.string(),
+  suggestedDifficulty: z.enum(["Very Easy", "Easy", "Medium", "Hard", "Expert"]),
+  loId: z.string(),
+  isCompleted: z.boolean()
+});
+var WeeklyRoadmapSchema = z.object({
+  generatedAt: z.number(),
+  items: z.array(RoadmapItemSchema)
+});
+var AnalysisReportSchema = z.object({
+  generatedAt: z.number(),
+  startDate: z.string(),
+  endDate: z.string(),
+  effortAndConsistencyRemarks: z.string(),
+  strengths: z.array(z.string()),
+  areasForImprovement: z.array(z.string()),
+  gamificationRemarks: z.string()
+});
+var LearningAnalysisOutputSchema = z.object({
+  analysisReport: AnalysisReportSchema.optional(),
+  weeklyRoadmap: WeeklyRoadmapSchema.optional()
+});
+
+// src/ai/flows/generate-learning-analysis.ts
+async function generateLearningAnalysis(clientInput, apiKey) {
+  try {
+    const ai = genkit({
+      plugins: [googleAI({ apiKey })],
+      model: gemini20Flash
+    });
+    const {
+      language,
+      userName = "learner",
+      weeklyGoal = 5,
+      unlockedAchievements,
+      stats,
+      history,
+      startDate,
+      endDate,
+      allAvailableTopics
+    } = clientInput;
+    const filteredHistory = history.filter(
+      (session) => session.timestamp >= new Date(startDate).getTime() && session.timestamp <= new Date(endDate).setHours(23, 59, 59, 999)
+    );
+    const promptText = `
+You are an expert AI Learning Coach. Your task is to analyze a student's learning data and generate a comprehensive JSON object containing an analysis report and a suggested weekly roadmap.
+
+**Student Data:**
+- Name: ${userName}
+- Weekly Goal: ${weeklyGoal} sessions
+- Unlocked Achievements: ${JSON.stringify(unlockedAchievements.map((a) => a.name))}
+- Overall Performance Stats (for context): ${JSON.stringify(stats, null, 2)}
+- Detailed Practice History (for analysis): ${JSON.stringify(filteredHistory, null, 2)}
+- **Source of Truth - All Available Topics**: ${JSON.stringify(allAvailableTopics, null, 2)}
+
+**CRITICAL INSTRUCTIONS:**
+You MUST generate a single JSON object with two main keys: "analysisReport" and "weeklyRoadmap".
+All topic names and loIds in your "weeklyRoadmap" output MUST be chosen directly from the "All Available Topics" list provided above. DO NOT invent topics or loIds.
+
+--- LOGIC FLOW ---
+
+**IF Practice History is NOT EMPTY:**
+1.  **For "analysisReport":**
+    - Analyze the data strictly within the period from ${startDate} to ${endDate}.
+    - **effortAndConsistencyRemarks**: Write a personalized comment on the student's effort.
+    - **strengths**: Identify 2-3 topics where the student performed best.
+    - **areasForImprovement**: Identify 2-3 topics where the student struggled the most.
+    - **gamificationRemarks**: Write an encouraging message mentioning their achievements.
+2.  **For "weeklyRoadmap":**
+    - Create a 5-item roadmap for the upcoming week.
+    - Prioritize the "areasForImprovement" you identified. For each, find the corresponding entry in "All Available Topics" and use its "topicName" and "loId".
+    - If more items are needed, select related topics from "All Available Topics".
+
+**IF Practice History IS EMPTY:**
+1.  **For "analysisReport":**
+    - **effortAndConsistencyRemarks**: Write a welcoming message for a new learner, encouraging them to start their journey.
+    - **strengths**: Return an empty array [].
+    - **areasForImprovement**: Return an empty array [].
+    - **gamificationRemarks**: Write a general motivational message about starting to learn.
+2.  **For "weeklyRoadmap":**
+    - Create a 5-item "starter" roadmap.
+    - Select 5 diverse and foundational topics directly from the "All Available Topics" list. Use their exact "topicName" and "loId".
+    - For the "reason", explain that this is a good starting point to explore the subject.
+
+--- END LOGIC FLOW ---
+
+**CRITICAL JSON OUTPUT FORMAT:**
+Return ONLY the JSON object. All descriptive string content (like remarks, strengths, reasons) MUST be in ${language}.
+The 'suggestedDifficulty' field MUST ALWAYS be one of these exact English strings: 'Very Easy', 'Easy', 'Medium', 'Hard', 'Expert'.
+
+\`\`\`json
+{
+  "analysisReport": {
+    "generatedAt": ${Date.now()},
+    "startDate": "${startDate}",
+    "endDate": "${endDate}",
+    "effortAndConsistencyRemarks": "Your detailed remarks...",
+    "strengths": ["Topic A", "Subject B"],
+    "areasForImprovement": ["Topic C", "Topic D"],
+    "gamificationRemarks": "Your encouraging remarks..."
+  },
+  "weeklyRoadmap": {
+    "generatedAt": ${Date.now()},
+    "items": [
+      {
+        "day": "Monday",
+        "topicName": "Topic C",
+        "reason": "To strengthen your understanding of this key area.",
+        "suggestedDifficulty": "Easy",
+        "loId": "lo-id-for-topic-c-from-the-list",
+        "isCompleted": false
+      }
+    ]
+  }
+}
+\`\`\`
+`;
+    const response = await ai.generate(promptText);
+    const rawText = response.text;
+    const jsonText = extractJsonFromMarkdown(rawText);
+    const aiGeneratedContent = JSON.parse(jsonText);
+    const validatedOutput = LearningAnalysisOutputSchema.parse(aiGeneratedContent);
+    return validatedOutput;
+  } catch (error) {
+    console.error("Error generating learning analysis:", error);
+    if (error instanceof z.ZodError) {
+      throw new Error(`AI returned data in an unexpected format. Validation failed: ${error.message}`);
+    }
+    const errorMessage = String(error.message || "");
+    if (errorMessage.includes("503") || errorMessage.toLowerCase().includes("service unavailable") || errorMessage.toLowerCase().includes("overloaded")) {
+      throw new Error("D\u1ECBch v\u1EE5 AI hi\u1EC7n \u0111ang qu\xE1 t\u1EA3i. Vui l\xF2ng th\u1EED l\u1EA1i sau \xEDt ph\xFAt.");
+    }
+    throw new Error(`Failed to generate learning analysis: ${errorMessage}`);
+  }
+}
+z.object({
+  language: z.string(),
+  userName: z.string().optional(),
+  currentStreak: z.number().optional(),
+  weakestTopic: z.string().optional()
+});
+var GenerateMotivationalQuoteOutputSchema = z.object({
+  text: z.string(),
+  author: z.string()
+});
+
+// src/ai/flows/generate-motivational-quote.ts
+async function generateMotivationalQuote(clientInput, apiKey) {
+  try {
+    const ai = genkit({
+      plugins: [googleAI({ apiKey })],
+      model: gemini20Flash
+    });
+    const { language, userName, currentStreak, weakestTopic } = clientInput;
+    let contextPrompt = "";
+    if (userName) {
+      contextPrompt += `The student's name is ${userName}. Address them directly.`;
+    }
+    if (currentStreak && currentStreak > 1) {
+      contextPrompt += ` They are on a ${currentStreak}-day practice streak. Acknowledge this achievement.`;
+    }
+    if (weakestTopic) {
+      contextPrompt += ` They seem to be struggling with the topic "${weakestTopic}". Encourage them to persevere on this topic.`;
+    }
+    const promptText = `
+You are an AI Learning Coach. Your task is to generate a single, short, and powerful motivational quote for a student.
+
+**Context about the student:**
+${contextPrompt || "No specific context provided, generate a general motivational quote about learning."}
+
+**Instructions:**
+1.  Create a quote that is concise (under 20 words).
+2.  The quote must be encouraging and relevant to learning or perseverance.
+3.  If context is provided, subtly weave it into the quote.
+4.  The quote must be in the following language: ${language}.
+
+**JSON OUTPUT FORMAT:**
+Return the response as a single, valid JSON object with this EXACT format:
+{
+  "text": "Your generated motivational quote here.",
+  "author": "AI Tutor"
+}
+
+Return only the JSON response.`;
+    try {
+      const response = await ai.generate(promptText);
+      const rawText = response.text;
+      const jsonText = extractJsonFromMarkdown(rawText);
+      const aiGeneratedContent = JSON.parse(jsonText);
+      const validatedOutput = GenerateMotivationalQuoteOutputSchema.parse(aiGeneratedContent);
+      return validatedOutput;
+    } catch (apiError) {
+      console.warn(`Could not generate AI motivational quote due to an API error: ${apiError.message}. Falling back to static quotes.`);
+      return null;
+    }
+  } catch (error) {
+    console.error("An unexpected error occurred in the generateMotivationalQuote flow:", error);
+    return null;
+  }
+}
+z.object({
+  language: z.string(),
+  learningObjectivesContent: z.string().min(50, { message: "Learning objectives content must be substantial." }),
+  overallSubject: z.string().min(1, { message: "Overall subject is required for context." })
+});
+var PlanKnowledgeCardsOutputSchema = z.object({
+  concepts: z.array(z.string()).min(1, { message: "AI should identify at least one concept." })
+});
+
+// src/ai/flows/plan-knowledge-cards.ts
+async function planKnowledgeCards(clientInput, apiKey) {
+  try {
+    const ai = genkit({
+      plugins: [googleAI({ apiKey })],
+      model: gemini20Flash
+    });
+    const { language, learningObjectivesContent, overallSubject } = clientInput;
+    const promptText = `
+You are an expert curriculum designer specializing in the subject of "${overallSubject}".
+Your task is to analyze the provided learning objectives and identify the most critical concepts, keywords, and technical terms that a student must know.
+
+**Provided Learning Objectives Document:**
+---
+${learningObjectivesContent}
+---
+
+**Instructions:**
+1.  Read the entire document carefully to understand the scope of the subject matter.
+2.  Identify between 15 and 20 of the most fundamental and important concepts.
+3.  Focus on nouns, technical terms, and core principles (e.g., "Variable", "Optional Chaining", "Protocol", "Delegate Pattern").
+4.  Do not select broad, generic phrases. The concepts should be specific enough to be explained on a single flashcard.
+5.  List these concepts in ${language}.
+
+**JSON OUTPUT FORMAT:**
+Return a single, valid JSON object with this EXACT format:
+{
+  "concepts": [
+    "First Concept",
+    "Second Concept",
+    "Third Concept",
+    ...
+  ]
+}
+
+Return only the JSON response.`;
+    const response = await ai.generate(promptText);
+    const rawText = response.text;
+    const jsonText = extractJsonFromMarkdown(rawText);
+    const aiGeneratedContent = JSON.parse(jsonText);
+    const validatedOutput = PlanKnowledgeCardsOutputSchema.parse(aiGeneratedContent);
+    return validatedOutput;
+  } catch (error) {
+    console.error("Error planning knowledge cards:", error);
+    if (error instanceof z.ZodError) {
+      throw new Error(`AI returned data in an unexpected format for planning. Validation failed: ${error.message}`);
+    }
+    throw new Error(`Failed to plan knowledge cards: ${error.message}`);
+  }
+}
+z.object({
+  language: z.string(),
+  concept: z.string().min(1, { message: "Concept cannot be empty." }),
+  overallSubject: z.string().min(1, { message: "Overall subject is required for context." }),
+  fullContext: z.string().optional().describe("The full learning objectives document for context reference.")
+});
+var GenerateSingleKnowledgeCardOutputSchema = z.object({
+  concept: z.string(),
+  definition: z.string(),
+  example: z.string()
+});
+
+// src/ai/flows/generate-single-knowledge-card.ts
+async function generateSingleKnowledgeCard(clientInput, apiKey) {
+  const ai = genkit({
+    plugins: [googleAI({ apiKey })],
+    model: gemini20Flash
+  });
+  try {
+    const { language, concept, overallSubject, fullContext } = clientInput;
+    const promptText = `
+You are an expert educator for "${overallSubject}". Create content for a single knowledge card.
+Target Concept: ${concept}
+Instructions:
+1.  Write a concise "definition" (under 40 words).
+2.  Provide a practical "example" (code or real-world scenario) relevant to "${overallSubject}".
+3.  All content must be in ${language}.
+4.  The 'concept' field in your output must exactly match the Target Concept.`;
+    const response = await ai.generate({
+      prompt: promptText,
+      output: {
+        schema: GenerateSingleKnowledgeCardOutputSchema
+      }
+    });
+    const validatedOutput = response.output;
+    if (!validatedOutput) {
+      throw new Error("AI did not return a valid structured output.");
+    }
+    return validatedOutput;
+  } catch (error) {
+    console.error(`Error generating knowledge card for concept "${clientInput.concept}":`, error);
+    if (error instanceof z.ZodError) {
+      throw new Error(`AI output validation failed for card "${clientInput.concept}". Error: ${error.message}`);
+    }
+    throw new Error(`Failed to generate knowledge card for "${clientInput.concept}": ${error.message}`);
+  }
+}
+var LearningObjectiveContextSchema = z.object({
+  loId: z.string(),
+  subject: z.string(),
+  category: z.string(),
+  topic: z.string(),
+  loDescription: z.string()
+});
+z.object({
+  language: z.string().default("English"),
+  documentContent: z.string().min(100, { message: "Document content must be substantial enough for analysis." }),
+  learningObjectives: z.array(LearningObjectiveContextSchema).min(1, { message: "At least one learning objective is required for mapping." })
+});
+var MappedLOSchema = z.object({
+  loId: z.string().describe("The exact loId from the provided learning objectives list that matches the document content."),
+  confidence: z.number().min(0).max(100).describe("A confidence score (0-100) of how well the document maps to this LO."),
+  reasoning: z.string().describe("A brief explanation for why this mapping is relevant.")
+});
+var AssessAndMapDocumentOutputSchema = z.object({
+  relevanceScore: z.number().min(0).max(100).describe("An overall score (0-100) indicating how relevant the document is to the provided learning objectives as a whole."),
+  isFreestyleRecommended: z.boolean().describe("A simple recommendation. True if the document is not relevant enough to be part of the structured curriculum."),
+  mappedLOs: z.array(MappedLOSchema).describe("A list of specific learning objectives the document is mapped to. Empty if not relevant.")
+});
+
+// src/ai/flows/assess-and-map-document.ts
+async function assessAndMapDocument(clientInput, apiKey) {
+  try {
+    const ai = genkit({
+      plugins: [googleAI({ apiKey })],
+      model: gemini20Flash
+    });
+    const { language, documentContent, learningObjectives } = clientInput;
+    const relevanceThreshold = 40;
+    const promptText = `
+You are an expert curriculum analyst. Your task is to analyze a given document and determine how relevant it is to a provided list of learning objectives (LOs).
+
+**INPUT DATA:**
+
+1.  **DOCUMENT CONTENT (first 1000 characters):**
+    ---
+    ${documentContent.substring(0, 1e3)}...
+    ---
+
+2.  **LIST OF AVAILABLE LEARNING OBJECTIVES:**
+    ---
+    ${JSON.stringify(learningObjectives, null, 2)}
+    ---
+
+**YOUR ANALYSIS TASKS:**
+
+1.  **Overall Relevance Assessment:** Read the document content and compare it against the entire list of LOs. Assign an overall "relevanceScore" from 0 (completely unrelated) to 100 (perfectly aligned with one or more LOs).
+
+2.  **Specific Mapping:** Identify which specific LOs from the list are directly addressed by the document. For each match you find, provide:
+    - The exact "loId" of the matched LO.
+    - A "confidence" score (0-100) for that specific match.
+    - A brief "reasoning" in ${language} explaining why the document content maps to that LO.
+
+3.  **Recommendation:** Based on your overall relevanceScore, provide a boolean recommendation "isFreestyleRecommended". This should be \`true\` if the relevanceScore is below ${relevanceThreshold}, and \`false\` otherwise.
+
+**CRITICAL JSON OUTPUT FORMAT:**
+Return a single, valid JSON object in this EXACT format. Do not include any other text or markdown.
+
+\`\`\`json
+{
+  "relevanceScore": 85,
+  "isFreestyleRecommended": false,
+  "mappedLOs": [
+    {
+      "loId": "SWIFT_FUNC_01",
+      "confidence": 95,
+      "reasoning": "The document provides a detailed explanation of function syntax and default parameters, which directly aligns with this learning objective."
+    }
+  ]
+}
+\`\`\`
+
+If the document is not relevant at all, the "mappedLOs" array should be empty, and the "relevanceScore" should be low.
+`;
+    const response = await ai.generate(promptText);
+    const rawText = response.text;
+    const jsonText = extractJsonFromMarkdown(rawText);
+    const aiGeneratedContent = JSON.parse(jsonText);
+    const validatedOutput = AssessAndMapDocumentOutputSchema.parse(aiGeneratedContent);
+    return validatedOutput;
+  } catch (error) {
+    console.error("Error in assessAndMapDocument flow:", error);
+    if (error instanceof z.ZodError) {
+      throw new Error(`AI output validation failed: ${error.message}`);
+    }
+    throw new Error(`Failed to assess document: ${error.message}`);
+  }
+}
+z.object({
+  language: z.string().optional().default("English"),
+  documentContent: z.string().min(100, { message: "Document content must be substantial enough to generate a quiz." }),
+  numQuestions: z.number().int().min(1).max(20).optional().default(10),
+  questionTypes: z.array(z.enum(["multiple_choice", "true_false", "short_answer"])).optional()
+});
+var AnyGeneratedQuestionSchema = z.union([
+  MultipleChoiceQuestionZodSchema,
+  TrueFalseQuestionZodSchema,
+  ShortAnswerQuestionZodSchema
+]);
+var GenerateQuizFromTextOutputSchema = z.object({
+  generatedQuestions: z.array(AnyGeneratedQuestionSchema)
+});
+
+// src/ai/flows/generate-quiz-from-text.ts
+var AnyGeneratedQuestionSchema2 = GenerateQuizFromTextOutputSchema.shape.generatedQuestions.element;
+async function generateQuizFromText(clientInput, apiKey) {
+  try {
+    const ai = genkit({
+      plugins: [googleAI({ apiKey })],
+      model: gemini20Flash
+    });
+    const { language, documentContent, numQuestions, questionTypes } = clientInput;
+    const allowedTypes = questionTypes || ["multiple_choice", "true_false"];
+    const promptText = `
+You are an expert educator. Your task is to create a quiz with exactly ${numQuestions} questions based SOLELY on the provided document content.
+
+**DOCUMENT CONTENT:**
+---
+${documentContent}
+---
+
+**QUIZ REQUIREMENTS:**
+1.  **Total Questions:** Generate exactly ${numQuestions} questions.
+2.  **Language:** All content (prompts, options, explanations) must be in ${language}.
+3.  **Content Source:** All questions MUST be derived directly from the provided DOCUMENT CONTENT. Do not use any external knowledge.
+4.  **Question Types:** Use a mix of the following question types: ${allowedTypes.join(", ")}. Prioritize 'multiple_choice'.
+5.  **Key Concepts:** Focus on the most important facts, definitions, and concepts within the text.
+6.  **Explanations:** Provide a brief, clear explanation for each question, referencing the source text.
+
+**OUTPUT FORMAT:**
+Return the response as a single JSON object with a key "generatedQuestions" containing an array of exactly ${numQuestions} question objects. Do NOT include any other text or markdown formatting outside of the JSON object.
+
+**Example of the JSON structure:**
+\`\`\`json
+{
+  "generatedQuestions": [
+    {
+      "questionType": "multiple_choice",
+      "prompt": "Based on the text, what is the primary function of a mitochondria?",
+      "options": [
+        { "tempId": "A", "text": "Cellular respiration" },
+        { "tempId": "B", "text": "Photosynthesis" },
+        { "tempId": "C", "text": "Protein synthesis" }
+      ],
+      "correctTempOptionId": "A",
+      "explanation": "The document states that mitochondria are the powerhouses of the cell, responsible for cellular respiration.",
+      "points": 10,
+      "difficulty": "medium",
+      "topic": "Cell Biology"
+    },
+    {
+      "questionType": "true_false",
+      "prompt": "The document indicates that the cell wall is found in both plant and animal cells.",
+      "correctAnswer": false,
+      "explanation": "The text specifies that the cell wall is a feature of plant cells, not animal cells.",
+      "points": 10,
+      "difficulty": "easy",
+      "topic": "Cell Biology"
+    }
+  ]
+}
+\`\`\`
+
+Now, generate the JSON response.`;
+    const response = await ai.generate(promptText);
+    const rawText = response.text;
+    const jsonText = extractJsonFromMarkdown(rawText);
+    const aiGeneratedContent = JSON.parse(jsonText);
+    if (!aiGeneratedContent.generatedQuestions || !Array.isArray(aiGeneratedContent.generatedQuestions)) {
+      throw new Error("AI did not return a valid 'generatedQuestions' array.");
+    }
+    const finalQuestions = [];
+    for (const rawQuestion of aiGeneratedContent.generatedQuestions) {
+      try {
+        const questionId = generateUniqueId(`${rawQuestion.questionType}_`);
+        let finalQuestion = null;
+        switch (rawQuestion.questionType) {
+          case "multiple_choice": {
+            const tempOptions = rawQuestion.options || [];
+            const finalOptions = tempOptions.map((opt) => ({
+              id: generateUniqueId("opt_"),
+              text: opt.text,
+              tempId: opt.tempId
+            }));
+            const correctTempId = rawQuestion.correctTempOptionId;
+            const correctFinalOption = finalOptions.find((opt) => opt.tempId === correctTempId);
+            if (!correctFinalOption) {
+              console.warn(`Skipping MCQ due to invalid correctTempOptionId: ${correctTempId}`);
+              continue;
+            }
+            finalQuestion = __spreadProps(__spreadValues({}, rawQuestion), {
+              id: questionId,
+              options: finalOptions.map((_a) => {
+                var _b = _a, { tempId } = _b, rest = __objRest(_b, ["tempId"]);
+                return rest;
+              }),
+              correctAnswerId: correctFinalOption.id
+            });
+            break;
+          }
+          case "true_false":
+          case "short_answer": {
+            finalQuestion = __spreadProps(__spreadValues({}, rawQuestion), { id: questionId });
+            break;
+          }
+          default:
+            console.warn(`Unsupported question type generated by AI: ${rawQuestion.questionType}. Skipping.`);
+            continue;
+        }
+        const validatedQuestion = AnyGeneratedQuestionSchema2.parse(finalQuestion);
+        finalQuestions.push(validatedQuestion);
+      } catch (error) {
+        console.error("Error processing a single generated question:", error, "Question data:", rawQuestion);
+      }
+    }
+    return { generatedQuestions: finalQuestions };
+  } catch (error) {
+    console.error("Error generating quiz from text:", error);
+    if (error instanceof z.ZodError) {
+      throw new Error(`AI output validation failed: ${error.message}`);
+    }
+    throw new Error(`Failed to generate quiz from text: ${error.message}`);
+  }
+}
 
-export { generateFillInTheBlanksQuestion, generateMCQQuestion, generateMRQQuestion, generateMatchingQuestion, generateNumericQuestion, generateQuestionsFromQuizPlan, generateQuizPlan, generateSequenceQuestion, generateShortAnswerQuestion, generateTrueFalseQuestion };
+export { assessAndMapDocument, generateFillInTheBlanksQuestion, generateLearningAnalysis, generateMCQQuestion, generateMRQQuestion, generateMatchingQuestion, generateMotivationalQuote, generateNumericQuestion, generatePracticeSuggestion, generateQuestionsFromQuizPlan, generateQuizFromText, generateQuizPlan, generateQuizReview, generateSequenceQuestion, generateShortAnswerQuestion, generateSingleKnowledgeCard, generateTrueFalseQuestion, planKnowledgeCards };