Upload 63 files

ai-context.js

@@ -1,7 +1,7 @@
 
 const { 
     User, Student, Score, AttendanceModel, ClassModel, 
-    LeaveRequestModel, TodoModel, School, Course 
+    Course, ConfigModel 
 } = require('./models');
 
 /**
@@ -13,6 +13,16 @@ const getCurrentDateInfo = () => {
     return `${now.getFullYear()}年${now.getMonth() + 1}月${now.getDate()}日 ${days[now.getDay()]}`;
 };
 
+/**
+ * 辅助函数：解析学年前缀
+ * 例如 "2023-2024学年 第二学期" -> "2023-2024学年"
+ */
+const getSchoolYearPrefix = (semester) => {
+    if (!semester) return null;
+    const match = semester.match(/^(.+?学年)/);
+    return match ? match[1] : null;
+};
+
 /**
  * 构建学生画像上下文 (学生视角)
  */
@@ -24,13 +34,29 @@ async function buildStudentContext(username, schoolId) {
 
     if (!student) return "无法找到该学生的详细档案。";
 
-    // 1. 获取近期成绩 (最近20条)
-    const recentScores = await Score.find({ 
+    // 获取当前学期配置
+    const config = await ConfigModel.findOne({ key: 'main' });
+    const currentSemester = config ? config.semester : null;
+    
+    // 逻辑：尝试拉取本学年的所有数据 (第一学期 + 第二学期)
+    const schoolYearPrefix = getSchoolYearPrefix(currentSemester);
+
+    const scoreQuery = { 
         studentNo: student.studentNo, 
         schoolId 
-    }).sort({ _id: -1 }).limit(20);
+    };
+    
+    if (schoolYearPrefix) {
+        // 匹配该学年开头的所有学期
+        scoreQuery.semester = { $regex: new RegExp('^' + schoolYearPrefix) };
+    } else if (currentSemester) {
+        scoreQuery.semester = currentSemester;
+    }
+
+    // 获取成绩 (稍微放宽限制以容纳整年数据)
+    const recentScores = await Score.find(scoreQuery).sort({ semester: -1, _id: -1 }).limit(100);
 
-    // 2. 获取考勤概况
+    // 获取考勤概况
     const attendanceStats = await AttendanceModel.aggregate([
         { $match: { studentId: student._id.toString() } },
         { $group: { _id: "$status", count: { $sum: 1 } } }
@@ -44,28 +70,33 @@ async function buildStudentContext(username, schoolId) {
 - **班级**: ${student.className}
 - **学号**: ${student.studentNo}
 - **积分(小红花)**: ${student.flowerBalance} 🌺
+- **当前学期**: ${currentSemester || '全部'}
 
 ### 个人学习数据
 `;
 
     if (recentScores.length > 0) {
-        prompt += `- **成绩历史**: ${recentScores.map(s => `${s.courseName}: ${s.score}分 (${s.examName||s.type})`).join('; ')}\n`;
+        // 格式化输出，带上学期标识
+        const scoreList = recentScores.map(s => {
+            const semShort = s.semester ? s.semester.replace(schoolYearPrefix || '', '').trim() : '';
+            return `${s.courseName}: ${s.score} (${semShort} ${s.examName||s.type})`;
+        }).join('\n');
+        prompt += `#### 成绩记录 (本学年):\n${scoreList}\n`;
     } else {
         prompt += `- **近期成绩**: 暂无记录\n`;
     }
 
     if (absentCount > 0 || leaveCount > 0) {
-        prompt += `- **考勤异常**: 本学期缺勤 ${absentCount} 次，请假 ${leaveCount} 次。\n`;
+        prompt += `- **考勤**: 缺勤 ${absentCount} 次，请假 ${leaveCount} 次。\n`;
     } else {
-        prompt += `- **考勤状况**: 全勤，表现极佳。\n`;
+        prompt += `- **考勤**: 全勤。\n`;
     }
 
     return prompt;
 }
 
 /**
- * 构建教师画像上下文 (严格权限版)
- * 核心逻辑：只查自己教的班级，只查自己教的课（除非是班主任）
+ * 构建教师画像上下文 (严格权限版 + 全量数据)
  */
 async function buildTeacherContext(username, schoolId) {
     const user = await User.findOne({ username, schoolId });
@@ -73,92 +104,119 @@ async function buildTeacherContext(username, schoolId) {
 
     const homeroomClass = user.homeroomClass; 
     
-    // 1. 查找所有任课信息
+    // 1. 查找任教课程信息 (确定科任权限)
     const courses = await Course.find({ 
         schoolId, 
         $or: [{ teacherId: user._id }, { teacherName: user.trueName || user.username }] 
     });
 
-    // 2. 构建权限映射
-    // authorizedClasses: Set<string> -> 老师有权限查看的班级列表
+    // 2. 确定有权限的班级列表
     const authorizedClasses = new Set();
-    // teachingSubjects: Map<className, Set<subjectName>> -> 每个班级教哪些课
-    const teachingSubjects = {};
+    const teachingSubjectsMap = {}; // Map<ClassName, Set<SubjectName>>
 
-    if (homeroomClass) authorizedClasses.add(homeroomClass);
+    // 班主任权限：拥有该班级所有数据权限
+    if (homeroomClass) {
+        authorizedClasses.add(homeroomClass);
+    }
 
+    // 科任权限：拥有特定班级的特定科目权限
     courses.forEach(c => {
-        authorizedClasses.add(c.className);
-        if (!teachingSubjects[c.className]) teachingSubjects[c.className] = new Set();
-        teachingSubjects[c.className].add(c.courseName);
+        if (c.className) {
+            authorizedClasses.add(c.className);
+            if (!teachingSubjectsMap[c.className]) teachingSubjectsMap[c.className] = new Set();
+            teachingSubjectsMap[c.className].add(c.courseName);
+        }
     });
 
     const classList = Array.from(authorizedClasses);
 
     if (classList.length === 0) {
-        return `### 当前用户身份：教师\n- **姓名**: ${user.trueName || username}\n- **状态**: 暂未绑定任何班级或课程。请告知用户去“班级管理”或“课程安排”绑定。`;
+        return `### 当前用户身份：教师 (${user.trueName})\n目前系统显示您未绑定任何班级。请告知用户去“班级管理”或“课程安排”进行绑定。`;
     }
 
-    // 3. 构建详细数据 Prompt
-    let prompt = `
-### 当前用户身份：教师
-- **姓名**: ${user.trueName || username}
-- **管理权限范围**: [${classList.join(', ')}]
-- **注意**: 你 **绝对不能** 回答关于上述班级以外的任何学生数据。如果用户问其他班级（如“四年级6班”），请明确拒绝，并告知用户系统记录显示他只负责上述班级。
-
-### 详细班级数据
-`;
-
-    // 4. 并行获取所有相关班级的学生
-    // 移除 limit，获取全量学生
-    const allStudents = await Student.find({ 
+    // 3. 全量拉取相关班级的学生
+    const students = await Student.find({ 
         schoolId, 
         className: { $in: classList },
-        status: 'Enrolled'
-    }).sort({ seatNo: 1, studentNo: 1 });
+        status: 'Enrolled' 
+    }).sort({ seatNo: 1, studentNo: 1 }); // 按座号排序
+
+    if (students.length === 0) {
+        return `### 当前用户身份：教师\n管理班级: [${classList.join(', ')}]\n但系统未在这些班级找到学生档案。`;
+    }
+
+    const studentNos = students.map(s => s.studentNo);
+
+    // 4. 拉取这些学生的成绩 (限制为本学年：包含第一学期和第二学期)
+    const config = await ConfigModel.findOne({ key: 'main' });
+    const currentSemester = config ? config.semester : null;
+    const schoolYearPrefix = getSchoolYearPrefix(currentSemester);
 
-    // 5. 获取这些学生的所有成绩
-    const allStudentNos = allStudents.map(s => s.studentNo);
-    const allScores = await Score.find({ 
+    const scoreQuery = { 
         schoolId, 
-        studentNo: { $in: allStudentNos },
+        studentNo: { $in: studentNos },
         status: 'Normal'
-    });
+    };
+
+    // 关键修复：使用正则匹配整个学年 (例如 "2024-2025学年")
+    if (schoolYearPrefix) {
+        scoreQuery.semester = { $regex: new RegExp('^' + schoolYearPrefix) };
+    } else if (currentSemester) {
+        // 如果无法解析年份，回退到当前学期
+        scoreQuery.semester = currentSemester;
+    }
 
-    // 6. 按班级组装数据
-    for (const clsName of classList) {
-        const isHomeroom = clsName === homeroomClass;
-        const subjectsTaught = teachingSubjects[clsName] ? Array.from(teachingSubjects[clsName]) : [];
-        
-        prompt += `\n#### 🏫 ${clsName} (${isHomeroom ? '我是班主任' : '我是任课老师'})\n`;
-        if (!isHomeroom && subjectsTaught.length > 0) {
-            prompt += `(非班主任视角：我只教 ${subjectsTaught.join(', ')}，仅展示这些科目的成绩)\n`;
-        }
+    const allScores = await Score.find(scoreQuery);
+
+    // 5. 构建 Prompt
+    let prompt = `
+### 当前用户身份：教师 (${user.trueName || username})
+### 权限范围 (严格遵守)
+你只能回答下列班级的数据。如果用户询问其他班级（例如用户只教一年级，却问四年级），请礼貌拒绝，说明权限不足。
+管理班级: [${classList.join(', ')}]
+数据范围: ${schoolYearPrefix ? schoolYearPrefix + " (全学年)" : (currentSemester || '所有历史')}
 
-        const classStudents = allStudents.filter(s => s.className === clsName);
+### 详细班级数据
+`;
+
+    for (const cls of classList) {
+        const isClassHomeroom = cls === homeroomClass;
+        const subjects = teachingSubjectsMap[cls] ? Array.from(teachingSubjectsMap[cls]) : [];
+        const roleText = isClassHomeroom ? "班主任 (全科权限)" : `任课老师 (科目: ${subjects.join(', ')})`;
+        
+        prompt += `\n#### 🏫 ${cls} [${roleText}]\n`;
         
-        if (classStudents.length === 0) {
-            prompt += `- (暂无学生档案)\n`;
+        const clsStudents = students.filter(s => s.className === cls);
+        if (clsStudents.length === 0) {
+            prompt += "(暂无学生)\n";
             continue;
         }
 
-        // 组装每个学生的信息
-        const studentLines = classStudents.map(s => {
-            let stuScores = allScores.filter(sc => sc.studentNo === s.studentNo);
+        prompt += `学生总数: ${clsStudents.length}人\n名单及成绩 (格式: [学期]科目:分数):\n`;
+
+        for (const s of clsStudents) {
+            let sScores = allScores.filter(sc => sc.studentNo === s.studentNo);
             
-            // 权限过滤：如果不是班主任，过滤掉不教的科目
-            if (!isHomeroom) {
-                stuScores = stuScores.filter(sc => subjectsTaught.includes(sc.courseName));
+            // 如果不是班主任，仅展示自己教的科目成绩
+            if (!isClassHomeroom && subjects.length > 0) {
+                sScores = sScores.filter(sc => subjects.includes(sc.courseName));
             }
 
-            // 格式化成绩： [数学:90, 英语:85(期末)]
-            const scoreStrs = stuScores.map(sc => `${sc.courseName}:${sc.score}${sc.examName && sc.examName!=='期末考试' ? '('+sc.examName+')' : ''}`);
-            const scoreText = scoreStrs.length > 0 ? `成绩:[${scoreStrs.join(', ')}]` : "无相关成绩";
-
-            return `- ${s.name}(${s.seatNo || '-'}号): ${scoreText}`;
-        });
-
-        prompt += studentLines.join('\n') + '\n';
+            // 格式: 张三(01号): [一]语文:90, [二]语文:85...
+            const scoreStr = sScores.length > 0 
+                ? sScores.map(sc => {
+                    // 简化学期显示，例如 "第一学期" -> "一", "第二学期" -> "二"
+                    let semLabel = "";
+                    if (sc.semester && schoolYearPrefix) {
+                        if (sc.semester.includes("第一")) semLabel = "[上]";
+                        else if (sc.semester.includes("第二")) semLabel = "[下]";
+                    }
+                    return `${semLabel}${sc.courseName}:${sc.score}`;
+                }).join(', ') 
+                : (isClassHomeroom ? "暂无本学年成绩" : "无本科目成绩");
+
+            prompt += `- ${s.name} (${s.seatNo ? s.seatNo+'号' : '无座号'}): ${scoreStr}\n`;
+        }
     }
 
     return prompt;
@@ -195,10 +253,11 @@ async function buildUserContext(username, role, schoolId) {
 ${roleContext}
 
 【AI 行为准则】
-1. **诚实原则**: 数据里有什么就说什么。如果数据里没有（例如学生列表里没这个名字，或者成绩列表为空），直接说“系统里没有记录”。不要编造。
-2. **权限原则**: 严格遵守上述“管理权限范围”。用户问其他班级时，礼貌拒绝。
-3. **数据格式**: 上下文中的数据格式为 "姓名: 成绩:[科目:分数...]"。
-4. **回答风格**: 像一位专业的教务助理，简洁明了。
+1. **数据优先**: 回答问题时，**必须**基于上述提供的具体数据。不要编造。
+2. **权限边界**: 只要上下文中没有的数据（例如其他班级），一律视为“无权限”或“无记录”，并告知用户。
+3. **列表完整性**: 如果用户问“有哪些学生”，请列出上述数据中该班级的所有学生名字，不要省略。
+4. **成绩解释**: 数据中标注了 [上] 代表第一学期，[下] 代表第二学期。如果用户问“本学期”，默认指第二学期(如果是下)或第一学期(如果是上)。
+5. **回答风格**: 简洁、专业、像一位教务助手。
 ---
 `;
     } catch (e) {

ai-routes.js

@@ -5,6 +5,7 @@ const OpenAI = require('openai');
 const { ConfigModel, User, AIUsageModel, ChatHistoryModel } = require('./models');
 const { buildUserContext } = require('./ai-context');
 
+// ... (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' });
@@ -25,6 +26,266 @@ async function recordUsage(model, provider) {
     } catch (e) { console.error("Failed to record AI usage stats:", e); }
 }
 
+const wait = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+async function callAIWithRetry(aiModelCall, retries = 1) {
+    for (let i = 0; i < retries; i++) {
+        try { return await aiModelCall(); }
+        catch (e) {
+            if (e.status === 400 || e.status === 401 || e.status === 403) throw e;
+            if (i < retries - 1) { await wait(1000 * Math.pow(2, i)); continue; }
+            throw e;
+        }
+    }
+}
+
+function convertGeminiToOpenAI(baseParams) {
+    const messages = [];
+    if (baseParams.config?.systemInstruction) messages.push({ role: 'system', content: baseParams.config.systemInstruction });
+    
+    let contents = baseParams.contents;
+    if (contents && !Array.isArray(contents)) {
+        contents = [contents];
+    }
+
+    if (contents && Array.isArray(contents)) {
+        contents.forEach(content => {
+            let role = (content.role === 'model' || content.role === 'assistant') ? 'assistant' : 'user';
+            const messageContent = [];
+            if (content.parts) {
+                content.parts.forEach(p => {
+                    if (p.text) messageContent.push({ type: 'text', text: p.text });
+                    else if (p.inlineData && p.inlineData.mimeType.startsWith('image/')) {
+                        messageContent.push({ type: 'image_url', image_url: { url: `data:${p.inlineData.mimeType};base64,${p.inlineData.data}` } });
+                    }
+                });
+            }
+            if (messageContent.length > 0) {
+                if (messageContent.length === 1 && messageContent[0].type === 'text') {
+                    messages.push({ role: role, content: messageContent[0].text });
+                } else {
+                    messages.push({ role: role, content: messageContent });
+                }
+            }
+        });
+    }
+    return messages;
+}
+
+const PROVIDERS = { GEMINI: 'GEMINI', OPENROUTER: 'OPENROUTER', GEMMA: 'GEMMA' };
+const DEFAULT_OPENROUTER_MODELS = ['qwen/qwen3-coder:free', 'openai/gpt-oss-120b:free', 'qwen/qwen3-235b-a22b:free', 'tngtech/deepseek-r1t-chimera:free'];
+
+// Runtime override logic
+let runtimeProviderOrder = [];
+
+function deprioritizeProvider(providerName) {
+    if (runtimeProviderOrder.length > 0 && runtimeProviderOrder[runtimeProviderOrder.length - 1] === providerName) return;
+    console.log(`[AI System] ⚠️ Deprioritizing ${providerName} due to errors. Moving to end of queue.`);
+    runtimeProviderOrder = runtimeProviderOrder.filter(p => p !== providerName).concat(providerName);
+    console.log(`[AI System] 🔄 New Priority Order: ${runtimeProviderOrder.join(' -> ')}`);
+}
+
+function isQuotaError(e) {
+    const msg = (e.message || '').toLowerCase();
+    return e.status === 429 || e.status === 503 || msg.includes('quota') || msg.includes('overloaded') || msg.includes('resource_exhausted') || msg.includes('rate limit') || msg.includes('credits');
+}
+
+// Streaming Helpers
+async function streamGemini(baseParams, res) {
+    const { GoogleGenAI } = await import("@google/genai");
+    const models = ['gemini-2.5-flash', 'gemini-2.5-flash-lite'];
+    const keys = await getKeyPool('gemini');
+    if (keys.length === 0) throw new Error("No Gemini API keys");
+    
+    for (const apiKey of keys) {
+        const client = new GoogleGenAI({ apiKey });
+        for (const modelName of models) {
+            try {
+                console.log(`[AI] 🚀 Attempting Gemini Model: ${modelName} (Key ends with ...${apiKey.slice(-4)})`);
+                const result = await client.models.generateContentStream({ ...baseParams, model: modelName });
+                
+                let hasStarted = false;
+                let fullText = "";
+                
+                for await (const chunk of result) {
+                    if (!hasStarted) {
+                        console.log(`[AI] ✅ Connected to Gemini: ${modelName}`);
+                        recordUsage(modelName, PROVIDERS.GEMINI);
+                        hasStarted = true;
+                    }
+                    if (chunk.text) {
+                        fullText += chunk.text;
+                        res.write(`data: ${JSON.stringify({ text: chunk.text })}\n\n`);
+                        if (res.flush) res.flush();
+                    }
+                }
+                return fullText;
+            } catch (e) {
+                console.warn(`[AI] ⚠️ Gemini ${modelName} Error: ${e.message}`);
+                if (isQuotaError(e)) {
+                    console.log(`[AI] 🔄 Quota exceeded for ${modelName}, trying next...`);
+                    continue; 
+                } 
+                throw e; 
+            }
+        }
+    }
+    throw new Error("Gemini streaming failed (All keys/models exhausted)");
+}
+
+async function streamOpenRouter(baseParams, res) {
+    const config = await ConfigModel.findOne({ key: 'main' });
+    const models = (config && config.openRouterModels?.length) ? config.openRouterModels.map(m => m.id) : DEFAULT_OPENROUTER_MODELS;
+    const messages = convertGeminiToOpenAI(baseParams);
+    const keys = await getKeyPool('openrouter');
+    if (keys.length === 0) throw new Error("No OpenRouter API keys");
+    
+    if (messages.length === 0) {
+        throw new Error("Conversion resulted in empty messages array. Check input format.");
+    }
+
+    for (const apiKey of keys) {
+        for (const modelName of models) {
+            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,
+                    ...extraBody 
+                });
+                
+                console.log(`[AI] ✅ Connected to ${providerLabel}: ${modelName}`);
+                recordUsage(modelName, PROVIDERS.OPENROUTER);
+                
+                let fullText = '';
+                for await (const chunk of stream) {
+                    const text = chunk.choices[0]?.delta?.content || '';
+                    if (text) {
+                        fullText += text;
+                        res.write(`data: ${JSON.stringify({ text: text })}\n\n`);
+                        if (res.flush) res.flush();
+                    }
+                }
+                return fullText;
+            } catch (e) { 
+                console.warn(`[AI] ⚠️ ${providerLabel} ${modelName} Error: ${e.message}`);
+                if (isQuotaError(e)) {
+                    console.log(`[AI] 🔄 Rate limit/Quota for ${modelName}, switching...`);
+                    break;
+                }
+            }
+        }
+    }
+    throw new Error("OpenRouter/Custom stream failed (All models exhausted)");
+}
+
+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'); 
+    if (keys.length === 0) throw new Error("No keys for Gemma");
+    
+    for (const apiKey of keys) {
+        const client = new GoogleGenAI({ apiKey });
+        for (const modelName of models) {
+            try {
+                console.log(`[AI] 🚀 Attempting Gemma Model: ${modelName}`);
+                const result = await client.models.generateContentStream({ ...baseParams, model: modelName });
+                
+                let hasStarted = false;
+                let fullText = "";
+                for await (const chunk of result) {
+                    if (!hasStarted) {
+                        console.log(`[AI] ✅ Connected to Gemma: ${modelName}`);
+                        recordUsage(modelName, PROVIDERS.GEMMA);
+                        hasStarted = true;
+                    }
+                    if (chunk.text) {
+                        fullText += chunk.text;
+                        res.write(`data: ${JSON.stringify({ text: chunk.text })}\n\n`);
+                        if (res.flush) res.flush();
+                    }
+                }
+                return fullText;
+            } catch (e) { 
+                console.warn(`[AI] ⚠️ Gemma ${modelName} Error: ${e.message}`);
+                if (isQuotaError(e)) continue; 
+            }
+        }
+    }
+    throw new Error("Gemma stream failed");
+}
+
+async function streamContentWithSmartFallback(baseParams, res) {
+    let hasAudio = false;
+    const contentsArray = Array.isArray(baseParams.contents) ? baseParams.contents : [baseParams.contents];
+    
+    contentsArray.forEach(c => {
+        if (c && c.parts) {
+            c.parts.forEach(p => { if (p.inlineData && p.inlineData.mimeType.startsWith('audio/')) hasAudio = true; });
+        }
+    });
+    
+    if (hasAudio) {
+        try { 
+            console.log(`[AI] 🎤 Audio detected, forcing Gemini provider.`);
+            return await streamGemini(baseParams, res); 
+        } catch(e) { 
+            console.error(`[AI] ❌ Audio Processing Failed: ${e.message}`);
+            deprioritizeProvider(PROVIDERS.GEMINI); 
+            throw new Error('QUOTA_EXCEEDED_AUDIO'); 
+        }
+    }
+    
+    const config = await ConfigModel.findOne({ key: 'main' });
+    const configuredOrder = config?.aiProviderOrder && config.aiProviderOrder.length > 0 
+        ? config.aiProviderOrder 
+        : [PROVIDERS.GEMINI, PROVIDERS.OPENROUTER, PROVIDERS.GEMMA];
+
+    const runtimeSet = new Set(runtimeProviderOrder);
+    if (runtimeProviderOrder.length === 0 || runtimeProviderOrder.length !== configuredOrder.length || !configuredOrder.every(p => runtimeSet.has(p))) {
+        runtimeProviderOrder = [...configuredOrder];
+    }
+
+    let finalError = null;
+    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); 
+                continue; 
+            }
+            continue; 
+        }
+    }
+    throw finalError || new Error('All streaming models unavailable.');
+}
+
 const checkAIAccess = async (req, res, next) => {
     const username = req.headers['x-user-username'];
     const role = req.headers['x-user-role'];
@@ -64,29 +325,21 @@ router.get('/stats', checkAIAccess, async (req, res) => {
 });
 
 router.post('/reset-pool', checkAIAccess, (req, res) => { 
+    runtimeProviderOrder = []; 
+    console.log('[AI] 🔄 Provider priority pool reset.');
     res.json({ success: true }); 
 });
 
-function convertHistoryToOpenAI(history) {
-    return history.map(msg => ({
-        role: msg.role === 'model' ? 'assistant' : 'user',
-        content: msg.parts ? msg.parts.map(p => p.text).join('') : (msg.text || '')
-    }));
-}
-
-// --- SSE Protocol Helper ---
-const sendSSE = (res, data) => {
-    res.write(`data: ${JSON.stringify(data)}\n\n`);
-};
-
-// --- STANDARD CHAT ROUTE (Context Injection Only) ---
+// --- 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 } = 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'];
     const userRole = req.headers['x-user-role'];
     const schoolId = req.headers['x-school-id'];
 
-    // SSE Setup
     res.setHeader('Content-Type', 'text/event-stream');
     res.setHeader('Cache-Control', 'no-cache');
     res.setHeader('Connection', 'keep-alive');
@@ -96,86 +349,177 @@ router.post('/chat', checkAIAccess, async (req, res) => {
         const user = await User.findOne({ username });
         if (!user) throw new Error('User not found');
 
-        // 1. Save User Message
+        // 1. SAVE USER MSG TO DB
         const userMsgText = text || (audio ? '(Audio Message)' : '');
         if (userMsgText) {
             await ChatHistoryModel.create({ userId: user._id, role: 'user', text: userMsgText });
         }
 
-        const config = await ConfigModel.findOne({ key: 'main' });
+        // 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);
         
-        // 2. Build Context (The Heavy Lifting)
-        const contextPrompt = await buildUserContext(username, userRole, schoolId);
+        // 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.
         
-        // Setup OpenAI Client
-        const keys = await getKeyPool('openrouter'); 
-        if (keys.length === 0) throw new Error("No API keys available");
+        const fullContents = [...historyContext];
         
-        let modelName = 'qwen/qwen3-coder:free';
-        let apiUrl = 'https://openrouter.ai/api/v1'; 
-        if (config?.openRouterModels && config.openRouterModels.length > 0) {
-            const m = config.openRouterModels[0];
-            modelName = m.id;
-            if (m.apiUrl) apiUrl = m.apiUrl;
+        // 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 } }] 
+            });
         }
 
-        console.log(`🤖 [Standard Chat] ${modelName} @ ${apiUrl}`);
-        
-        const client = new OpenAI({ 
-            baseURL: apiUrl, 
-            apiKey: keys[0], 
-            defaultHeaders: { "HTTP-Referer": "https://smart.com" } 
-        });
-
-        // 3. Build History
-        const dbHistory = await ChatHistoryModel.find({ userId: user._id }).sort({ timestamp: -1 }).limit(10);
-        let messages = [
-            { role: 'system', content: contextPrompt },
-            ...convertHistoryToOpenAI(dbHistory.reverse())
-        ];
-        if (text) messages.push({ role: 'user', content: text });
-
-        // 4. Stream Response
-        const stream = await client.chat.completions.create({
-            model: modelName,
-            messages: messages,
-            stream: true
-        });
+        // --- NEW: Inject Context ---
+        const contextPrompt = await buildUserContext(username, userRole, schoolId);
+        const baseSystemInstruction = "你是一位友善、耐心且知识渊博的中小学AI助教。请用简洁、鼓励性的语言回答学生的问题。回复支持 Markdown 格式。";
+        const combinedSystemInstruction = `${baseSystemInstruction}\n${contextPrompt}`;
+        // ---------------------------
 
-        let finalResponseText = "";
+        const answerText = await streamContentWithSmartFallback({
+            contents: fullContents, 
+            config: { systemInstruction: combinedSystemInstruction }
+        }, res);
 
-        for await (const chunk of stream) {
-            const delta = chunk.choices[0]?.delta?.content;
-            if (delta) {
-                finalResponseText += delta;
-                sendSSE(res, { type: 'text', content: delta });
-            }
-        }
+        // 4. SAVE AI RESPONSE TO DB
+        if (answerText) {
+            await ChatHistoryModel.create({ userId: user._id, role: 'model', text: answerText });
 
-        // 5. Save Final Answer
-        if (finalResponseText) {
-            await ChatHistoryModel.create({ userId: user._id, role: 'model', text: finalResponseText });
+            // Signal that text generation is done and TTS is starting
+            res.write(`data: ${JSON.stringify({ status: 'tts' })}\n\n`);
+            try {
+                const { GoogleGenAI } = await import("@google/genai");
+                const keys = await getKeyPool('gemini');
+                let audioBytes = null;
+                for (const apiKey of keys) {
+                    try {
+                        const client = new GoogleGenAI({ apiKey });
+                        const ttsResponse = await client.models.generateContent({
+                            model: "gemini-2.5-flash-preview-tts", 
+                            contents: [{ parts: [{ text: answerText }] }],
+                            config: { responseModalities: ['AUDIO'], speechConfig: { voiceConfig: { prebuiltVoiceConfig: { voiceName: 'Kore' } } } }
+                        });
+                        audioBytes = ttsResponse.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
+                        if (audioBytes) break;
+                    } catch(e) { if (isQuotaError(e)) continue; break; }
+                }
+                if (audioBytes) res.write(`data: ${JSON.stringify({ audio: audioBytes })}\n\n`);
+                else res.write(`data: ${JSON.stringify({ ttsSkipped: true })}\n\n`);
+            } catch (ttsError) { res.write(`data: ${JSON.stringify({ ttsSkipped: true })}\n\n`); }
         }
-        recordUsage('chat-response', 'STANDARD');
-
-        sendSSE(res, { type: 'done' });
-        res.end();
-
+        res.write('data: [DONE]\n\n'); res.end();
     } catch (e) {
-        console.error("[AI Chat Error]", e);
-        sendSSE(res, { type: 'error', message: e.message });
-        res.end();
+        console.error("[AI Chat Route Error]", e);
+        res.write(`data: ${JSON.stringify({ error: true, message: e.message })}\n\n`); res.end();
     }
 });
 
-// ... (Rest of the file: evaluate route, export)
+// STREAMING ASSESSMENT ENDPOINT
 router.post('/evaluate', checkAIAccess, async (req, res) => {
     const { question, audio, image, images } = req.body;
     res.setHeader('Content-Type', 'text/event-stream');
     res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
     res.flushHeaders();
-    res.write(`data: ${JSON.stringify({ error: true, message: "Use Gemeni provider for multimodel evaluation" })}\n\n`);
-    res.end();
+
+    try {
+        res.write(`data: ${JSON.stringify({ status: 'analyzing' })}\n\n`);
+
+        const evalParts = [{ text: `请作为一名严谨的老师，对学生的回答进行评分。题目是：${question}。` }];
+        if (audio) {
+            evalParts.push({ text: "学生的回答在音频中。" });
+            evalParts.push({ inlineData: { mimeType: 'audio/webm', data: audio } });
+        }
+        
+        // Support multiple images
+        if (images && Array.isArray(images) && images.length > 0) {
+            evalParts.push({ text: "学生的回答写在以下图片中，请识别所有图片中的文字内容并进行批改：" });
+            images.forEach(img => {
+                if(img) evalParts.push({ inlineData: { mimeType: 'image/jpeg', data: img } });
+            });
+        } else if (image) {
+            // Legacy single image support
+            evalParts.push({ text: "学生的回答写在图片中，请识别图片中的文字内容并进行批改。" });
+            evalParts.push({ inlineData: { mimeType: 'image/jpeg', data: image } });
+        }
+
+        // Force structured markdown output for streaming parsing
+        evalParts.push({ text: `请分析：1. 内容准确性 2. 表达/书写规范。
+        必须严格按照以下格式输出(不要使用Markdown代码块包裹):
+        
+        ## Transcription
+        (在此处输出识别到的学生回答内容，如果是图片则为识别的文字)
+        
+        ## Feedback
+        (在此处输出简短的鼓励性评语和建议)
+        
+        ## Score
+        (在此处仅输出一个0-100的数字)` });
+
+        // Stream Text
+        const fullText = await streamContentWithSmartFallback({
+            // CRITICAL FIX: Pass as array of objects for OpenRouter compatibility
+            contents: [{ role: 'user', parts: evalParts }],
+            // NO JSON MODE to allow progressive text streaming
+        }, res);
+
+        // Extract Feedback for TTS
+        const feedbackMatch = fullText.match(/## Feedback\s+([\s\S]*?)(?=## Score|$)/i);
+        const feedbackText = feedbackMatch ? feedbackMatch[1].trim() : "";
+
+        // Generate TTS if feedback exists
+        if (feedbackText) {
+            res.write(`data: ${JSON.stringify({ status: 'tts' })}\n\n`);
+            try {
+                const { GoogleGenAI } = await import("@google/genai");
+                const keys = await getKeyPool('gemini');
+                let feedbackAudio = null;
+                for (const apiKey of keys) {
+                    try {
+                        const client = new GoogleGenAI({ apiKey });
+                        const ttsResponse = await client.models.generateContent({
+                            model: "gemini-2.5-flash-preview-tts",
+                            contents: [{ parts: [{ text: feedbackText }] }],
+                            config: { responseModalities: ['AUDIO'], speechConfig: { voiceConfig: { prebuiltVoiceConfig: { voiceName: 'Kore' } } } }
+                        });
+                        feedbackAudio = ttsResponse.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
+                        if (feedbackAudio) break;
+                    } catch(e) { if (isQuotaError(e)) continue; break; }
+                }
+                if (feedbackAudio) res.write(`data: ${JSON.stringify({ audio: feedbackAudio })}\n\n`);
+                else res.write(`data: ${JSON.stringify({ ttsSkipped: true })}\n\n`);
+            } catch (ttsErr) { res.write(`data: ${JSON.stringify({ ttsSkipped: true })}\n\n`); }
+        }
+
+        res.write('data: [DONE]\n\n');
+        res.end();
+
+    } catch (e) {
+        console.error("AI Eval Error:", e);
+        res.write(`data: ${JSON.stringify({ error: true, message: e.message || "Evaluation failed" })}\n\n`);
+        res.end();
+    }
 });
 
 module.exports = router;