Upload 47 files

pages/AIAssistant.tsx

@@ -70,7 +70,7 @@ export const AIAssistant: React.FC = () => {
     const audioChunksRef = useRef<Blob[]>([]);
     const audioContextRef = useRef<AudioContext | null>(null);
     const currentSourceRef = useRef<AudioBufferSourceNode | null>(null);
-    const messagesEndRef = useRef<HTMLDivElement>(null); // New: Ref for auto-scrolling
+    const messagesEndRef = useRef<HTMLDivElement>(null); 
 
     // Initialize & Load Config
     useEffect(() => {
@@ -106,9 +106,16 @@ export const AIAssistant: React.FC = () => {
         }
     }, [messages]);
 
-    // Auto-scroll effect
+    // 1. Initial Scroll on Mount (Wait slightly for layout)
     useEffect(() => {
-        messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
+        setTimeout(() => {
+            messagesEndRef.current?.scrollIntoView({ behavior: 'auto', block: 'end' });
+        }, 100);
+    }, []);
+
+    // 2. Scroll on new messages or processing state change
+    useEffect(() => {
+        messagesEndRef.current?.scrollIntoView({ behavior: isProcessing ? 'auto' : 'smooth', block: 'end' });
     }, [messages, isProcessing]);
 
     const stopPlayback = () => {

server.js

@@ -7,7 +7,6 @@ const {
 } = require('./models');
 
 // Initialize OpenAI (OpenRouter) Client
-// We use lazy initialization inside the function to avoid crashes if API Key is missing initially
 const OpenAI = require('openai');
 let openAIClient = null;
 
@@ -205,17 +204,19 @@ function deprioritizeProvider(providerName) {
     // If it's already at the end, do nothing
     if (activeProviderOrder[activeProviderOrder.length - 1] === providerName) return;
     
-    console.log(`📉 Performance Opt: Deprioritizing ${providerName} due to quota limits.`);
+    console.log(`📉 [AI Debug] Performance Opt: Deprioritizing ${providerName} due to quota limits.`);
     // Move to end
     activeProviderOrder = activeProviderOrder.filter(p => p !== providerName).concat(providerName);
-    console.log(`🔄 New Provider Order: ${activeProviderOrder.join(' -> ')}`);
+    console.log(`🔄 [AI Debug] New Provider Order: ${activeProviderOrder.join(' -> ')}`);
 }
 
 function isQuotaError(e) {
+    const msg = e.message || '';
     return e.status === 429 || e.status === 503 || 
-           e.message?.includes('Quota') || 
-           e.message?.includes('overloaded') || 
-           e.message?.includes('RESOURCE_EXHAUSTED');
+           msg.includes('Quota') || 
+           msg.includes('overloaded') || 
+           msg.includes('RESOURCE_EXHAUSTED') ||
+           msg.includes('Rate limit');
 }
 
 // --- INDIVIDUAL PROVIDER CALLERS ---
@@ -229,12 +230,14 @@ async function callGeminiProvider(aiModelObj, baseParams) {
     let lastError = null;
     for (const modelName of primaryModels) {
         try {
+            console.log(`🚀 [AI Debug] Calling Gemini non-stream: ${modelName}`);
             const currentParams = { ...baseParams, model: modelName };
             return await callAIWithRetry(aiModelObj, currentParams, 1);
         } catch (e) {
             lastError = e;
+            console.error(`⚠️ [AI Debug] Gemini ${modelName} Error:`, e.status, e.message);
             if (isQuotaError(e)) {
-                console.warn(`⚠️ Gemini Model ${modelName} exhausted. Trying next internal model...`);
+                console.warn(`⚠️ [AI Debug] Gemini ${modelName} exhausted. Trying next internal model...`);
                 continue; 
             }
             throw e; // Fail fast on non-quota errors
@@ -259,7 +262,7 @@ async function callOpenRouterProvider(baseParams) {
 
     for (const modelName of openRouterModels) {
         try {
-            console.log(`🛡️ Switching to OpenRouter Model: ${modelName}`);
+            console.log(`🛡️ [AI Debug] Switching to OpenRouter Model: ${modelName}`);
             const completion = await openRouter.chat.completions.create({
                 model: modelName,
                 messages: openAIMessages,
@@ -275,7 +278,7 @@ async function callOpenRouterProvider(baseParams) {
 
         } catch (e) {
             lastError = e;
-            console.warn(`⚠️ OpenRouter Model ${modelName} failed.`, e.message);
+            console.warn(`⚠️ [AI Debug] OpenRouter Model ${modelName} failed.`, e.message);
             // Continue to next OpenRouter model
         }
     }
@@ -296,7 +299,7 @@ async function callGemmaProvider(aiModelObj, baseParams) {
     let lastError = null;
     for (const modelName of fallbackModels) {
         try {
-            console.log(`🛡️ Switching to Final Backup (Gemma 3): ${modelName}`);
+            console.log(`🛡️ [AI Debug] Switching to Final Backup (Gemma 3): ${modelName}`);
             const currentParams = { 
                 ...baseParams, 
                 model: modelName,
@@ -305,7 +308,7 @@ async function callGemmaProvider(aiModelObj, baseParams) {
             return await callAIWithRetry(aiModelObj, currentParams, 1);
         } catch (e) {
             lastError = e;
-            console.warn(`⚠️ Backup Model ${modelName} failed.`, e.message);
+            console.warn(`⚠️ [AI Debug] Backup Model ${modelName} failed.`, e.message);
         }
     }
     throw lastError || new Error("Gemma failed");
@@ -314,31 +317,86 @@ async function callGemmaProvider(aiModelObj, baseParams) {
 // --- STREAMING PROVIDER HELPERS ---
 
 async function streamGemini(aiModelObj, baseParams, res) {
-    const modelName = 'gemini-2.5-flash'; // For streaming, we mostly stick to Flash for speed
-    const currentParams = { ...baseParams, model: modelName };
-    const streamResult = await aiModelObj.generateContentStream(currentParams);
+    // Try multiple Flash models internally for quota resilience
+    const models = ['gemini-2.5-flash', 'gemini-2.5-flash-lite'];
     
-    let fullText = '';
-    for await (const chunk of streamResult) {
-        const text = chunk.text;
-        if (text) {
-            fullText += text;
-            res.write(`data: ${JSON.stringify({ text: text })}\n\n`);
+    let lastError = null;
+    for (const modelName of models) {
+        try {
+            console.log(`🌊 [AI Debug] STREAMING Gemini model: ${modelName}`);
+            const currentParams = { ...baseParams, model: modelName };
+            const streamResult = await aiModelObj.generateContentStream(currentParams);
+            
+            let fullText = '';
+            for await (const chunk of streamResult) {
+                const text = chunk.text;
+                if (text) {
+                    fullText += text;
+                    res.write(`data: ${JSON.stringify({ text: text })}\n\n`);
+                }
+            }
+            console.log(`✅ [AI Debug] Gemini ${modelName} stream complete.`);
+            return fullText; // Success
+        } catch (e) {
+            lastError = e;
+            console.error(`❌ [AI Debug] Gemini Stream Error (${modelName}):`, e.status, e.message);
+            
+            if (isQuotaError(e)) {
+                console.warn(`Stream Gemini ${modelName} quota exhausted. Switching...`);
+                continue; // Try next internal model
+            }
+            throw e; // Non-quota error, fail fast
         }
     }
-    return fullText;
+    throw lastError || new Error("Gemini streaming failed after retrying internal models");
+}
+
+async function streamGemma(aiModelObj, baseParams, res) {
+    const models = ['gemma-3-27b-it', 'gemma-3-12b-it', 'gemma-3-4b-it'];
+    const gemmaConfig = { ...baseParams.config };
+    if (gemmaConfig.systemInstruction) delete gemmaConfig.systemInstruction;
+
+    let lastError = null;
+    for (const modelName of models) {
+        try {
+            console.log(`🛡️ [AI Debug] Streaming Fallback to Gemma: ${modelName}`);
+            const currentParams = { ...baseParams, model: modelName, config: gemmaConfig };
+            const streamResult = await aiModelObj.generateContentStream(currentParams);
+            
+            let fullText = '';
+            for await (const chunk of streamResult) {
+                const text = chunk.text;
+                if (text) {
+                    fullText += text;
+                    res.write(`data: ${JSON.stringify({ text: text })}\n\n`);
+                }
+            }
+            return fullText;
+        } catch (e) {
+            lastError = e;
+            console.warn(`Stream Gemma ${modelName} failed: ${e.message}`);
+        }
+    }
+    throw lastError || new Error("Gemma streaming failed");
 }
 
 async function streamOpenRouter(baseParams, res) {
     const openRouter = getOpenRouter();
     if (!openRouter) throw new Error("OpenRouter not configured");
     
-    const openRouterModels = ['qwen/qwen3-coder:free', 'openai/gpt-oss-120b:free'];
+    // Updated free model list
+    const openRouterModels = [
+        'qwen/qwen3-coder:free',
+        'openai/gpt-oss-120b:free', 
+        'qwen/qwen3-235b-a22b:free',
+        'tngtech/deepseek-r1t-chimera:free'
+    ];
     const messages = convertGeminiToOpenAI(baseParams);
     
     let lastError = null;
     for (const modelName of openRouterModels) {
         try {
+            console.log(`🛡️ [AI Debug] Streaming via OpenRouter: ${modelName}`);
             const stream = await openRouter.chat.completions.create({
                 model: modelName,
                 messages: messages,
@@ -356,7 +414,12 @@ async function streamOpenRouter(baseParams, res) {
             return fullText;
         } catch (e) {
             lastError = e;
-            console.warn(`Stream OpenRouter ${modelName} failed`, e.message);
+            console.warn(`[AI Debug] Stream OpenRouter ${modelName} failed`, e.message);
+            if (isQuotaError(e)) {
+                // If Rate Limit, break loop to allow fallback to next PROVIDER immediately 
+                // instead of trying all OpenRouter models which share quota
+                throw e; 
+            }
         }
     }
     throw lastError || new Error("All OpenRouter streams failed");
@@ -381,9 +444,11 @@ async function generateContentWithSmartFallback(aiModelObj, baseParams) {
 
     // Constraint: Audio MUST use Gemini.
     if (hasAudio) {
+        console.log("🎤 [AI Debug] Audio detected, forcing Gemini.");
         try {
             return await callGeminiProvider(aiModelObj, baseParams);
         } catch (e) {
+            console.error("❌ [AI Debug] Audio Gemini Failed:", e.message);
             if (isQuotaError(e)) {
                 // Critical: Even if we fail this request, deprioritize Gemini for future TEXT requests
                 deprioritizeProvider(PROVIDERS.GEMINI);
@@ -414,7 +479,7 @@ async function generateContentWithSmartFallback(aiModelObj, baseParams) {
             }
             // If it's not a quota error (e.g. invalid input, 400 Bad Request due to image not supported by specific model),
             // we typically continue to the next provider to see if they can handle it.
-            console.warn(`⚠️ ${provider} failed with non-quota error:`, e.message);
+            console.warn(`⚠️ [AI Debug] ${provider} failed with non-quota error:`, e.message);
         }
     }
 
@@ -422,9 +487,6 @@ async function generateContentWithSmartFallback(aiModelObj, baseParams) {
 }
 
 async function streamContentWithSmartFallback(aiModelObj, baseParams, res) {
-    // Similar fallback logic but for streaming
-    // We only support streaming for TEXT generation primarily here.
-    
     // Check for Audio Input (Gemini Only)
     let hasAudio = false;
     if (baseParams.contents && Array.isArray(baseParams.contents)) {
@@ -448,6 +510,9 @@ async function streamContentWithSmartFallback(aiModelObj, baseParams, res) {
         }
     }
 
+    let finalError = null;
+    console.log(`🚦 [AI Debug] Starting stream with order: ${activeProviderOrder.join(' -> ')}`);
+
     for (const provider of activeProviderOrder) {
         try {
             if (provider === PROVIDERS.GEMINI) {
@@ -455,13 +520,11 @@ async function streamContentWithSmartFallback(aiModelObj, baseParams, res) {
             } else if (provider === PROVIDERS.OPENROUTER) {
                 return await streamOpenRouter(baseParams, res);
             } else if (provider === PROVIDERS.GEMMA) {
-                // Gemma via REST API doesn't support streaming well in this setup easily,
-                // fallback to non-streaming for Gemma but simulate output?
-                // For simplicity, we skip Gemma streaming or implement standard fetch.
-                // Let's just fallback to Gemini logic for now or skip.
-                continue;
+                // Now supports streaming fallback to Gemma
+                return await streamGemma(aiModelObj, baseParams, res);
             }
         } catch (e) {
+            finalError = e;
             if (isQuotaError(e)) {
                 deprioritizeProvider(provider);
                 continue;
@@ -469,7 +532,7 @@ async function streamContentWithSmartFallback(aiModelObj, baseParams, res) {
             console.warn(`Streaming ${provider} failed:`, e.message);
         }
     }
-    throw new Error('All streaming models unavailable.');
+    throw finalError || new Error('All streaming models unavailable.');
 }
 
 // --- Middleware: Check AI Access ---