Upload 63 files

ai-context.js

@@ -1,7 +1,7 @@
 
 const { 
     User, Student, Score, AttendanceModel, ClassModel, 
-    LeaveRequestModel, TodoModel, School 
+    LeaveRequestModel, TodoModel, School, Course 
 } = require('./models');
 
 /**
@@ -75,26 +75,63 @@ async function buildStudentContext(username, schoolId) {
 }
 
 /**
- * 构建教师画像上下文 (增强版 - 全班详情)
+ * 构建教师画像上下文 (增强版 - 智能区分班主任与科任视角)
  */
 async function buildTeacherContext(username, schoolId) {
     const user = await User.findOne({ username, schoolId });
     if (!user) return "无法找到该教师档案。";
 
-    const className = user.homeroomClass;
+    // 1. 确定老师的身份范围
+    const homeroomClassName = user.homeroomClass; // 班主任班级
+    
+    // 查找该老师任教的所有课程 (找出任教的其他班级)
+    const teachingCourses = await Course.find({ 
+        $or: [{ teacherId: user._id }, { teacherName: user.trueName || user.username }],
+        schoolId 
+    });
+    
+    // 构建任教班级 -> 科目列表的映射 (e.g., "三年级(2)班": ["数学", "科学"])
+    const teachingMap = {};
+    teachingCourses.forEach(c => {
+        if (!teachingMap[c.className]) teachingMap[c.className] = new Set();
+        teachingMap[c.className].add(c.courseName);
+    });
+
+    // 合并所有相关班级 (班主任班级 + 任课班级)
+    const allClasses = new Set(Object.keys(teachingMap));
+    if (homeroomClassName) allClasses.add(homeroomClassName);
+
+    if (allClasses.size === 0) {
+        return `### 当前用户身份：教师\n- **姓名**: ${user.trueName || username}\n- **状态**: 暂未绑定任何班级或课程数据。`;
+    }
+
     let prompt = `
 ### 当前用户身份：教师
 - **姓名**: ${user.trueName || username}
-- **任教科目**: ${user.teachingSubject || '未设置'}
+- **负责班级**: ${Array.from(allClasses).join(', ')}
 `;
 
-    if (className) {
-        // 1. 获取全班学生列表
+    // 2. 遍历所有相关班级，构建详细数据
+    for (const className of allClasses) {
+        const isHomeroom = className === homeroomClassName;
+        const subjectsTaught = teachingMap[className] ? Array.from(teachingMap[className]) : [];
+        
+        prompt += `\n#### 🏫 班级: ${className} (${isHomeroom ? '我是班主任' : '我是任课老师'})\n`;
+        if (!isHomeroom) {
+            prompt += `(非班主任视角：仅展示我任教的科目 [${subjectsTaught.join(', ')}] 的数据)\n`;
+        }
+
+        // 2.1 获取该班学生
         const students = await Student.find({ className, schoolId });
+        if (students.length === 0) {
+            prompt += `- 暂无学生数据\n`;
+            continue;
+        }
+        
         const studentNos = students.map(s => s.studentNo);
         const studentIds = students.map(s => s._id.toString());
 
-        // 2. 获取全班考勤统计 (Group by Student)
+        // 2.2 获取考勤 (全班)
         const attendanceRaw = await AttendanceModel.aggregate([
             { $match: { studentId: { $in: studentIds }, status: { $in: ['Absent', 'Leave'] } } },
             { $group: { _id: "$studentId", absent: { $sum: { $cond: [{ $eq: ["$status", "Absent"] }, 1, 0] } }, leave: { $sum: { $cond: [{ $eq: ["$status", "Leave"] }, 1, 0] } } } }
@@ -102,62 +139,62 @@ async function buildTeacherContext(username, schoolId) {
         const attendanceMap = {};
         attendanceRaw.forEach(a => attendanceMap[a._id] = a);
 
-        // 3. 获取全班近期成绩 (为了Token效率，我们只取每人最近3次考试或全班最近的100条成绩记录)
-        const recentScores = await Score.find({ schoolId, studentNo: { $in: studentNos } }).sort({ _id: -1 }).limit(200);
-        const scoreMap = {}; // studentNo -> [Score Obj]
-        recentScores.forEach(s => {
-            if (!scoreMap[s.studentNo]) scoreMap[s.studentNo] = [];
-            scoreMap[s.studentNo].push(s);
-        });
+        // 2.3 获取成绩 (按需获取)
+        // 查询该班级学生的所有成绩
+        // 为了性能，还是查出来再内存过滤，比多次DB查询快
+        const allScores = await Score.find({ 
+            schoolId, 
+            studentNo: { $in: studentNos }
+        }).sort({ _id: -1 }); // 最新的在前
 
-        // 4. 构建“全息花名册”字符串
-        let rosterStr = "";
-        const failingStudents = [];
-
-        students.forEach(s => {
+        // 构建每个学生的成绩摘要
+        const studentDetails = students.map(s => {
             const att = attendanceMap[s._id.toString()] || { absent: 0, leave: 0 };
-            const myScores = scoreMap[s.studentNo] || [];
             
-            // 计算个人概况
-            let scoreStr = "暂无成绩";
-            let avgScore = 0;
-            if (myScores.length > 0) {
-                // 只取最近3门
-                const latest3 = myScores.slice(0, 3);
-                scoreStr = latest3.map(sc => `${sc.courseName}:${sc.score}`).join(', ');
-                avgScore = latest3.reduce((a,b)=>a+b.score,0) / latest3.length;
-                
-                // 检查不及格
-                if (latest3.some(sc => sc.score < 60)) {
-                    failingStudents.push(s.name);
+            // 筛选该学生的成绩
+            let myScores = allScores.filter(sc => sc.studentNo === s.studentNo);
+
+            // 【关键逻辑】过滤显示哪些科目
+            if (!isHomeroom) {
+                // 如果不是班主任，只保留我教的科目的成绩
+                myScores = myScores.filter(sc => subjectsTaught.includes(sc.courseName));
+            }
+
+            // 【聚合逻辑】每个科目只取最近一次成绩 (去重)
+            const latestSubjectScores = {};
+            myScores.forEach(sc => {
+                if (!latestSubjectScores[sc.courseName]) {
+                    latestSubjectScores[sc.courseName] = sc;
                 }
+            });
+
+            const finalScores = Object.values(latestSubjectScores);
+            
+            // 格式化成绩字符串
+            let scoreStr = "";
+            if (finalScores.length > 0) {
+                scoreStr = finalScores.map(sc => `${sc.courseName}:${sc.score}`).join(', ');
+            } else {
+                scoreStr = "无相关成绩";
             }
 
-            // 格式: [姓名](座号): 考勤[缺x, 假y], 成绩[科目:分, ...], 积分: z
-            rosterStr += `- **${s.name}** (座号:${s.seatNo || '-'}): 考勤[缺${att.absent}/假${att.leave}], 小红花:${s.flowerBalance}, 近期成绩[${scoreStr}]\n`;
+            // 标记异常 (缺勤多 或 有不及格)
+            const hasIssue = att.absent > 0 || finalScores.some(sc => sc.score < 60);
+            const flag = hasIssue ? "⚠️" : "";
+
+            return `- ${flag} **${s.name}**: 考勤[缺${att.absent}/假${att.leave}], 小红花:${s.flowerBalance}, 最新成绩:[${scoreStr}]`;
         });
 
-        // 5. 待办审批
-        const pendingLeaves = await LeaveRequestModel.find({ className, schoolId, status: 'Pending' }).limit(5);
-        
-        prompt += `- **班级**: ${className} (共${students.length}人)\n`;
-        
-        if (pendingLeaves.length > 0) {
-            prompt += `\n### 🔴 紧急待办\n`;
-            prompt += `你有 ${pendingLeaves.length} 条请假申请待审批 (申请人: ${pendingLeaves.map(l => l.studentName).join(', ')})。\n`;
-        }
+        // 将学生列表加入 Prompt (限制长度，如果班级人太多，可能需要截断，但Gemini窗口大，通常没事)
+        prompt += studentDetails.join('\n') + '\n';
 
-        if (failingStudents.length > 0) {
-            prompt += `\n### ⚠️ 学情预警\n`;
-            prompt += `以下学生近期有不及格记录，请重点关注: ${failingStudents.join(', ')}\n`;
+        // 2.4 如果是班主任，额外显示待办
+        if (isHomeroom) {
+            const pendingLeaves = await LeaveRequestModel.countDocuments({ className, schoolId, status: 'Pending' });
+            if (pendingLeaves > 0) {
+                prompt += `> 🔴 班务提醒: 有 ${pendingLeaves} 条请假申请待审批。\n`;
+            }
         }
-
-        prompt += `\n### 📋 班级学生全息档案 (Roster)\n`;
-        prompt += `(这是你班级所有学生的详细数据，当用户询问具体学生时，请在此处检索)\n`;
-        prompt += rosterStr;
-
-    } else {
-        prompt += `- **班级**: 目前没有担任班主任，暂无详细学生数据。\n`;
     }
 
     return prompt;
@@ -220,10 +257,11 @@ async function buildUserContext(username, role, schoolId) {
 ${roleContext}
 
 【AI 行为准则】
-1. 你拥有上述所有数据的“上帝视角”。当老师问“张三的情况”时，请直接从【班级学生全息档案】中提取张三的成绩、考勤和小红花数据进行回答，不要说“我不知道”。
-2. 回答要具体。例如：不要说“他成绩一般”，要说“他最近数学考了60分，英语考了85分，属于偏科现象”。
-3. 如果数据中显示学生有缺勤或不及格，请在回答末尾给出具体的教学干预建议。
-4. 保持语气专业、辅助性强。
+1. 你拥有上述所有数据的“上帝视角”。
+2. **班主任视角**: 当用户是班主任时，你通过上下文已知晓全班所有科目的成绩。如果问“王五偏科吗”，请对比他的各科成绩作答。
+3. **任课老师视角**: 当用户非班主任时，你只能看到他所教科目的成绩。如果问“李华其他课怎么样”，请诚实回答“我只能看到您任教科目的数据，无法评价其他科目”。
+4. 回答要具体。不要说“他成绩一般”，要说“他最近数学考了60分，英语考了85分”。
+5. 数据格式说明: [科目:分数] 代表该科目最近一次录入的成绩。
 ---
 `;
     } catch (e) {

ai-routes.js

@@ -2,10 +2,10 @@
 const express = require('express');
 const router = express.Router();
 const OpenAI = require('openai');
-const { ConfigModel, User, AIUsageModel } = require('./models');
+const { ConfigModel, User, AIUsageModel, ChatHistoryModel } = require('./models');
 const { buildUserContext } = require('./ai-context');
 
-// ... (Key Management, Usage Tracking, Helpers, Provider Management functions remain same as before)
+// ... (Key Management, Usage Tracking, Helpers remain same)
 // Fetch keys from DB + merge with ENV variables
 async function getKeyPool(type) {
     const config = await ConfigModel.findOne({ key: 'main' });
@@ -42,7 +42,6 @@ function convertGeminiToOpenAI(baseParams) {
     const messages = [];
     if (baseParams.config?.systemInstruction) messages.push({ role: 'system', content: baseParams.config.systemInstruction });
     
-    // Normalize contents to array if it's a single object (Gemini allows shorthand, OpenAI/Middleware needs array)
     let contents = baseParams.contents;
     if (contents && !Array.isArray(contents)) {
         contents = [contents];
@@ -50,12 +49,7 @@ function convertGeminiToOpenAI(baseParams) {
 
     if (contents && Array.isArray(contents)) {
         contents.forEach(content => {
-            // Default to user role if not specified (common in short-hand calls)
             let role = (content.role === 'model' || content.role === 'assistant') ? 'assistant' : 'user';
-            
-            // Handle simple text shorthand if parts is missing but text exists (rare but possible in some SDK versions)
-            // But standard Gemini is { parts: [...] }
-            
             const messageContent = [];
             if (content.parts) {
                 content.parts.forEach(p => {
@@ -65,9 +59,7 @@ function convertGeminiToOpenAI(baseParams) {
                     }
                 });
             }
-            
             if (messageContent.length > 0) {
-                // If only one text part, send as string (cleaner for some weaker models)
                 if (messageContent.length === 1 && messageContent[0].type === 'text') {
                     messages.push({ role: role, content: messageContent[0].text });
                 } else {
@@ -86,11 +78,8 @@ const DEFAULT_OPENROUTER_MODELS = ['qwen/qwen3-coder:free', 'openai/gpt-oss-120b
 let runtimeProviderOrder = [];
 
 function deprioritizeProvider(providerName) {
-    // If the provider is already last, do nothing
     if (runtimeProviderOrder.length > 0 && runtimeProviderOrder[runtimeProviderOrder.length - 1] === providerName) return;
-    
     console.log(`[AI System] ⚠️ Deprioritizing ${providerName} due to errors. Moving to end of queue.`);
-    // Move to end
     runtimeProviderOrder = runtimeProviderOrder.filter(p => p !== providerName).concat(providerName);
     console.log(`[AI System] 🔄 New Priority Order: ${runtimeProviderOrder.join(' -> ')}`);
 }
@@ -114,7 +103,6 @@ async function streamGemini(baseParams, res) {
                 console.log(`[AI] 🚀 Attempting Gemini Model: ${modelName} (Key ends with ...${apiKey.slice(-4)})`);
                 const result = await client.models.generateContentStream({ ...baseParams, model: modelName });
                 
-                // First chunk check usually determines connection success
                 let hasStarted = false;
                 let fullText = "";
                 
@@ -135,9 +123,9 @@ async function streamGemini(baseParams, res) {
                 console.warn(`[AI] ⚠️ Gemini ${modelName} Error: ${e.message}`);
                 if (isQuotaError(e)) {
                     console.log(`[AI] 🔄 Quota exceeded for ${modelName}, trying next...`);
-                    continue; // Try next model or key
+                    continue; 
                 } 
-                throw e; // Non-quota errors bubble up to switch provider
+                throw e; 
             }
         }
     }
@@ -157,17 +145,32 @@ async function streamOpenRouter(baseParams, res) {
 
     for (const apiKey of keys) {
         for (const modelName of models) {
-            // Find specific model config to check for custom URL
             const modelConfig = config?.openRouterModels?.find(m => m.id === modelName);
             const baseURL = modelConfig?.apiUrl ? modelConfig.apiUrl : "https://openrouter.ai/api/v1";
             const providerLabel = modelConfig?.apiUrl ? 'Custom API' : 'OpenRouter';
             
             const client = new OpenAI({ baseURL, apiKey, defaultHeaders: { "HTTP-Referer": "https://smart.com", "X-Title": "Smart School" } });
             
+            // --- DOUBAO OPTIMIZATION (Context Caching) ---
+            const extraBody = {};
+            if (modelName.toLowerCase().includes('doubao')) {
+                console.log(`[AI] 💡 Activating Doubao Prefix Caching for ${modelName}`);
+                // Doubao-specific caching parameter
+                extraBody.caching = { type: "enabled", prefix: true };
+                // Disable thinking to save tokens/time if not needed (optional based on user pref, but here we prioritize speed for chat)
+                extraBody.thinking = { type: "disabled" };
+            }
+            // ---------------------------------------------
+
             try {
                 console.log(`[AI] 🚀 Attempting ${providerLabel} Model: ${modelName} (URL: ${baseURL})`);
                 
-                const stream = await client.chat.completions.create({ model: modelName, messages, stream: true });
+                const stream = await client.chat.completions.create({ 
+                    model: modelName, 
+                    messages, 
+                    stream: true,
+                    ...extraBody 
+                });
                 
                 console.log(`[AI] ✅ Connected to ${providerLabel}: ${modelName}`);
                 recordUsage(modelName, PROVIDERS.OPENROUTER);
@@ -186,7 +189,7 @@ async function streamOpenRouter(baseParams, res) {
                 console.warn(`[AI] ⚠️ ${providerLabel} ${modelName} Error: ${e.message}`);
                 if (isQuotaError(e)) {
                     console.log(`[AI] 🔄 Rate limit/Quota for ${modelName}, switching...`);
-                    break; // Switch to next provider/model logic if implemented in loop, here break to next model in loop
+                    break;
                 }
             }
         }
@@ -197,7 +200,7 @@ async function streamOpenRouter(baseParams, res) {
 async function streamGemma(baseParams, res) {
     const { GoogleGenAI } = await import("@google/genai");
     const models = ['gemma-3-27b-it', 'gemma-3-12b-it'];
-    const keys = await getKeyPool('gemini'); // Gemma uses Gemini keys
+    const keys = await getKeyPool('gemini'); 
     if (keys.length === 0) throw new Error("No keys for Gemma");
     
     for (const apiKey of keys) {
@@ -233,8 +236,6 @@ async function streamGemma(baseParams, res) {
 
 async function streamContentWithSmartFallback(baseParams, res) {
     let hasAudio = false;
-    
-    // Check if contents is array or object, handle accordingly
     const contentsArray = Array.isArray(baseParams.contents) ? baseParams.contents : [baseParams.contents];
     
     contentsArray.forEach(c => {
@@ -243,7 +244,6 @@ async function streamContentWithSmartFallback(baseParams, res) {
         }
     });
     
-    // Audio input currently forces Gemini
     if (hasAudio) {
         try { 
             console.log(`[AI] 🎤 Audio detected, forcing Gemini provider.`);
@@ -255,37 +255,26 @@ async function streamContentWithSmartFallback(baseParams, res) {
         }
     }
     
-    // FETCH CONFIG AND SET PROVIDER ORDER
     const config = await ConfigModel.findOne({ key: 'main' });
     const configuredOrder = config?.aiProviderOrder && config.aiProviderOrder.length > 0 
         ? config.aiProviderOrder 
         : [PROVIDERS.GEMINI, PROVIDERS.OPENROUTER, PROVIDERS.GEMMA];
 
-    // If runtime order is empty or contains different elements (e.g. config changed), reset it
     const runtimeSet = new Set(runtimeProviderOrder);
-    const configSet = new Set(configuredOrder);
     if (runtimeProviderOrder.length === 0 || runtimeProviderOrder.length !== configuredOrder.length || !configuredOrder.every(p => runtimeSet.has(p))) {
-        console.log(`[AI] 📋 Initializing Provider Order: ${configuredOrder.join(' -> ')}`);
         runtimeProviderOrder = [...configuredOrder];
-    } else {
-        console.log(`[AI] 📋 Current Provider Priority: ${runtimeProviderOrder.join(' -> ')}`);
     }
 
     let finalError = null;
-    
-    // Use runtimeProviderOrder which might have been adjusted due to quota errors in previous calls
     for (const provider of runtimeProviderOrder) {
         try {
             console.log(`[AI] 👉 Trying Provider: ${provider}...`);
-            
             if (provider === PROVIDERS.GEMINI) return await streamGemini(baseParams, res);
             else if (provider === PROVIDERS.OPENROUTER) return await streamOpenRouter(baseParams, res);
             else if (provider === PROVIDERS.GEMMA) return await streamGemma(baseParams, res);
-            
         } catch (e) {
             console.error(`[AI] ❌ Provider ${provider} Failed: ${e.message}`);
             finalError = e;
-            
             if (isQuotaError(e)) { 
                 console.log(`[AI] 📉 Quota/Rate Limit detected. Switching provider...`);
                 deprioritizeProvider(provider); 
@@ -294,8 +283,6 @@ async function streamContentWithSmartFallback(baseParams, res) {
             continue; 
         }
     }
-    
-    console.error(`[AI] 💀 All providers failed.`);
     throw finalError || new Error('All streaming models unavailable.');
 }
 
@@ -311,7 +298,6 @@ const checkAIAccess = async (req, res, next) => {
     next();
 };
 
-// NEW: Endpoint to provide a temporary key for Client-Side Live API
 router.get('/live-access', checkAIAccess, async (req, res) => {
     try {
         const keys = await getKeyPool('gemini');
@@ -339,13 +325,15 @@ router.get('/stats', checkAIAccess, async (req, res) => {
 });
 
 router.post('/reset-pool', checkAIAccess, (req, res) => { 
-    runtimeProviderOrder = []; // Will be re-initialized from DB on next call
+    runtimeProviderOrder = []; 
     console.log('[AI] 🔄 Provider priority pool reset.');
     res.json({ success: true }); 
 });
 
+// --- PERSISTENT CHAT HISTORY HANDLER ---
+// Instead of relying on client-side 'history', we use MongoDB to ensure cross-device memory.
 router.post('/chat', checkAIAccess, async (req, res) => {
-    const { text, audio, history } = req.body;
+    const { text, audio } = req.body; // Ignore req.body.history for prompt generation
     
     // Extract headers for context building
     const username = req.headers['x-user-username'];
@@ -356,16 +344,52 @@ router.post('/chat', checkAIAccess, async (req, res) => {
     res.setHeader('Cache-Control', 'no-cache');
     res.setHeader('Connection', 'keep-alive');
     res.flushHeaders();
+    
     try {
-        const fullContents = [];
-        if (history && Array.isArray(history)) {
-            history.forEach(msg => { if (msg.text) fullContents.push({ role: msg.role === 'user' ? 'user' : 'model', parts: [{ text: msg.text }] }); });
+        const user = await User.findOne({ username });
+        if (!user) throw new Error('User not found');
+
+        // 1. SAVE USER MSG TO DB
+        const userMsgText = text || (audio ? '(Audio Message)' : '');
+        if (userMsgText) {
+            await ChatHistoryModel.create({ userId: user._id, role: 'user', text: userMsgText });
+        }
+
+        // 2. FETCH HISTORY FROM DB (Long-term Memory)
+        // Retrieve last 30 messages for context
+        const dbHistory = await ChatHistoryModel.find({ userId: user._id })
+            .sort({ timestamp: -1 })
+            .limit(30);
+        
+        // Re-order for API (oldest first)
+        const historyContext = dbHistory.reverse().map(msg => ({
+            role: msg.role === 'user' ? 'user' : 'model',
+            parts: [{ text: msg.text }]
+        }));
+
+        // 3. PREPARE REQUEST
+        // The last user message is already in DB and retrieved in historyContext.
+        // We need to separate "history" from "current message" for some APIs, 
+        // but Google/OpenAI handle a list of messages fine.
+        // However, standard pattern is: History + Current.
+        // Since we fetched ALL (including current), we just pass historyContext as contents.
+        // NOTE: If audio is present, we must append it specifically as the "current" part 
+        // because DB only stores text representation for now.
+        
+        const fullContents = [...historyContext];
+        
+        // If this request has audio, append it as a new part (since DB load only has text placeholder)
+        // We replace the last 'user' text message with the audio payload for the AI model
+        if (audio) {
+            // Remove the text placeholder we just loaded
+            if (fullContents.length > 0 && fullContents[fullContents.length - 1].role === 'user') {
+                fullContents.pop();
+            }
+            fullContents.push({ 
+                role: 'user', 
+                parts: [{ inlineData: { mimeType: 'audio/webm', data: audio } }] 
+            });
         }
-        const currentParts = [];
-        if (audio) currentParts.push({ inlineData: { mimeType: 'audio/webm', data: audio } });
-        if (text) currentParts.push({ text: text });
-        if (currentParts.length === 0) currentParts.push({ text: "Hello" });
-        fullContents.push({ role: 'user', parts: currentParts });
 
         // --- NEW: Inject Context ---
         const contextPrompt = await buildUserContext(username, userRole, schoolId);
@@ -378,7 +402,10 @@ router.post('/chat', checkAIAccess, async (req, res) => {
             config: { systemInstruction: combinedSystemInstruction }
         }, res);
 
+        // 4. SAVE AI RESPONSE TO DB
         if (answerText) {
+            await ChatHistoryModel.create({ userId: user._id, role: 'model', text: answerText });
+
             // Signal that text generation is done and TTS is starting
             res.write(`data: ${JSON.stringify({ status: 'tts' })}\n\n`);
             try {

models.js

@@ -278,9 +278,20 @@ const AIUsageSchema = new mongoose.Schema({
 AIUsageSchema.index({ date: 1, model: 1, provider: 1 }, { unique: true });
 const AIUsageModel = mongoose.model('AIUsage', AIUsageSchema);
 
+// NEW: Persistent Chat History
+const ChatHistorySchema = new mongoose.Schema({
+    userId: { type: String, required: true, index: true },
+    role: { type: String, enum: ['user', 'model'], required: true },
+    text: { type: String, required: true },
+    timestamp: { type: Number, default: Date.now }
+});
+// Create index for fast retrieval of latest messages
+ChatHistorySchema.index({ userId: 1, timestamp: -1 });
+const ChatHistoryModel = mongoose.model('ChatHistory', ChatHistorySchema);
+
 module.exports = {
     School, User, Student, Course, Score, ClassModel, SubjectModel, ExamModel, ScheduleModel,
     ConfigModel, NotificationModel, GameSessionModel, StudentRewardModel, LuckyDrawConfigModel, GameMonsterConfigModel, GameZenConfigModel,
     AchievementConfigModel, TeacherExchangeConfigModel, StudentAchievementModel, AttendanceModel, LeaveRequestModel, SchoolCalendarModel,
-    WishModel, FeedbackModel, TodoModel, AIUsageModel
+    WishModel, FeedbackModel, TodoModel, AIUsageModel, ChatHistoryModel
 };