opencode-pollinations-plugin 5.1.3

package/dist/server/proxy.js

@@ -0,0 +1,588 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { loadConfig } from './config.js';
+import { handleCommand } from './commands.js';
+import { emitStatusToast, emitLogToast } from './toast.js';
+// --- PERSISTENCE: SIGNATURE MAP (Multi-Round Support) ---
+const SIG_FILE = path.join(process.env.HOME || '/tmp', '.config/opencode/pollinations-signature.json');
+let signatureMap = {};
+let lastSignature = null; // V1 Fallback Global
+function log(msg) {
+    try {
+        const ts = new Date().toISOString();
+        if (!fs.existsSync('/tmp/opencode_pollinations_debug.log')) {
+            fs.writeFileSync('/tmp/opencode_pollinations_debug.log', '');
+        }
+        fs.appendFileSync('/tmp/opencode_pollinations_debug.log', `[Proxy] ${ts} ${msg}\n`);
+    }
+    catch (e) { }
+}
+try {
+    if (fs.existsSync(SIG_FILE)) {
+        signatureMap = JSON.parse(fs.readFileSync(SIG_FILE, 'utf-8'));
+    }
+}
+catch (e) { }
+function saveSignatureMap() {
+    try {
+        if (!fs.existsSync(path.dirname(SIG_FILE)))
+            fs.mkdirSync(path.dirname(SIG_FILE), { recursive: true });
+        fs.writeFileSync(SIG_FILE, JSON.stringify(signatureMap, null, 2));
+    }
+    catch (e) {
+        log(`ERROR: Error mapping signature: ${String(e)}`);
+    }
+}
+// RECURSIVE NORMALIZER for Stable Hashing
+function normalizeContent(c) {
+    if (!c)
+        return "";
+    if (typeof c === 'string')
+        return c.replace(/\s+/g, ''); // Standard String
+    if (Array.isArray(c))
+        return c.map(normalizeContent).join(''); // Recurse Array
+    if (typeof c === 'object') {
+        const keys = Object.keys(c).sort();
+        return keys.map(k => k + normalizeContent(c[k])).join('');
+    }
+    return String(c);
+}
+function hashMessage(content) {
+    const normalized = normalizeContent(content);
+    let hash = 0;
+    for (let i = 0; i < normalized.length; i++) {
+        const char = normalized.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16);
+}
+// --- SANITIZATION HELPERS ---
+function dereferenceSchema(schema, rootDefs) {
+    if (!schema || typeof schema !== 'object')
+        return schema;
+    if (schema.$ref || schema.ref) {
+        const refKey = (schema.$ref || schema.ref).split('/').pop();
+        if (rootDefs && rootDefs[refKey]) {
+            const def = dereferenceSchema(JSON.parse(JSON.stringify(rootDefs[refKey])), rootDefs);
+            delete schema.$ref;
+            delete schema.ref;
+            Object.assign(schema, def);
+        }
+        else {
+            for (const key in schema) {
+                if (key !== 'description' && key !== 'default')
+                    delete schema[key];
+            }
+            schema.type = "string";
+            schema.description = (schema.description || "") + " [Ref Failed]";
+        }
+    }
+    if (schema.properties) {
+        for (const key in schema.properties) {
+            schema.properties[key] = dereferenceSchema(schema.properties[key], rootDefs);
+        }
+    }
+    if (schema.items) {
+        schema.items = dereferenceSchema(schema.items, rootDefs);
+    }
+    if (schema.optional !== undefined)
+        delete schema.optional;
+    if (schema.title)
+        delete schema.title;
+    return schema;
+}
+function sanitizeToolsForVertex(tools) {
+    return tools.map(tool => {
+        if (!tool.function || !tool.function.parameters)
+            return tool;
+        let params = tool.function.parameters;
+        const defs = params.definitions || params.$defs;
+        params = dereferenceSchema(params, defs);
+        if (params.definitions)
+            delete params.definitions;
+        if (params.$defs)
+            delete params.$defs;
+        tool.function.parameters = params;
+        return tool;
+    });
+}
+function truncateTools(tools, limit = 120) {
+    if (!tools || tools.length <= limit)
+        return tools;
+    return tools.slice(0, limit);
+}
+const MAX_RETRIES = 3;
+const RETRY_DELAY_MS = 1000;
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function fetchWithRetry(url, options, retries = MAX_RETRIES) {
+    try {
+        const response = await fetch(url, options);
+        if (response.ok)
+            return response;
+        if (response.status === 404 || response.status === 401 || response.status === 400) {
+            // Don't retry client errors (except rate limit)
+            return response;
+        }
+        if (retries > 0 && (response.status === 429 || response.status >= 500)) {
+            log(`[Retry] Upstream Error ${response.status}. Retrying in ${RETRY_DELAY_MS}ms... (${retries} left)`);
+            await sleep(RETRY_DELAY_MS);
+            return fetchWithRetry(url, options, retries - 1);
+        }
+        return response;
+    }
+    catch (error) {
+        if (retries > 0) {
+            log(`[Retry] Network Error: ${error}. Retrying... (${retries} left)`);
+            await sleep(RETRY_DELAY_MS);
+            return fetchWithRetry(url, options, retries - 1);
+        }
+        throw error;
+    }
+}
+// --- MAIN HANDLER ---
+export async function handleChatCompletion(req, res, bodyRaw) {
+    let targetUrl = '';
+    let authHeader = undefined;
+    try {
+        const body = JSON.parse(bodyRaw);
+        const config = loadConfig();
+        // 0. COMMAND HANDLING
+        if (body.messages && body.messages.length > 0) {
+            const lastMsg = body.messages[body.messages.length - 1];
+            if (lastMsg.role === 'user') {
+                let text = "";
+                if (typeof lastMsg.content === 'string') {
+                    text = lastMsg.content;
+                }
+                else if (Array.isArray(lastMsg.content)) {
+                    // Handle Multimodal [{type:'text', text:'...'}]
+                    text = lastMsg.content
+                        .map((c) => c.text || c.content || "")
+                        .join("");
+                }
+                text = text.trim();
+                log(`[Command Check] Extracted: "${text.substring(0, 50)}..." from type: ${typeof lastMsg.content}`);
+                if (text.startsWith('/pollinations') || text.startsWith('/poll')) {
+                    log(`[Command] Intercepting: ${text}`);
+                    const cmdResult = await handleCommand(text);
+                    if (cmdResult.handled) {
+                        if (true) { // ALWAYS MOCK STREAM for Compatibility
+                            res.writeHead(200, {
+                                'Content-Type': 'text/event-stream',
+                                'Cache-Control': 'no-cache',
+                                'Connection': 'keep-alive'
+                            });
+                            const content = cmdResult.response || cmdResult.error || "Commande exécutée.";
+                            const id = "pollinations-cmd-" + Date.now();
+                            const created = Math.floor(Date.now() / 1000);
+                            // Mock Chunk 1: Content
+                            const chunk1 = {
+                                id, object: "chat.completion.chunk", created, model: body.model,
+                                choices: [{ index: 0, delta: { role: "assistant", content }, finish_reason: null }]
+                            };
+                            res.write(`data: ${JSON.stringify(chunk1)}\n\n`);
+                            // Mock Chunk 2: Stop
+                            const chunk2 = {
+                                id, object: "chat.completion.chunk", created, model: body.model,
+                                choices: [{ index: 0, delta: {}, finish_reason: "stop" }]
+                            };
+                            res.write(`data: ${JSON.stringify(chunk2)}\n\n`);
+                            res.write("data: [DONE]\n\n");
+                            res.end();
+                            return; // SHORT CIRCUIT
+                        }
+                    }
+                }
+            }
+        }
+        log(`Incoming Model (OpenCode ID): ${body.model}`);
+        // 1. STRICT ROUTING & SAFETY NET LOGIC (V5)
+        let actualModel = body.model || "openai";
+        let isEnterprise = false;
+        let isFallbackActive = false;
+        let fallbackReason = "";
+        // LOAD QUOTA FOR SAFETY CHECKS
+        const { getQuotaStatus, formatQuotaForToast } = await import('./quota.js');
+        const quota = await getQuotaStatus(false);
+        // A. Resolve Base Target
+        if (actualModel.startsWith('enter/')) {
+            isEnterprise = true;
+            actualModel = actualModel.replace('enter/', '');
+        }
+        else if (actualModel.startsWith('free/')) {
+            isEnterprise = false;
+            actualModel = actualModel.replace('free/', '');
+        }
+        // B. SAFETY NETS (The Core V5 Logic)
+        if (config.mode === 'alwaysfree') {
+            if (isEnterprise) {
+                if (quota.tier === 'error') {
+                    log(`[SafetyNet] AlwaysFree Mode: Quota Check Failed. Switching to Free Fallback.`);
+                    actualModel = config.fallbacks.free.main.replace('free/', '');
+                    isEnterprise = false;
+                    isFallbackActive = true;
+                    fallbackReason = "Quota Unreachable (Safety)";
+                }
+                else if (quota.tierRemaining <= 0.1) {
+                    log(`[SafetyNet] AlwaysFree Mode: Daily Tier Empty. Switching to Free Fallback.`);
+                    actualModel = config.fallbacks.free.main.replace('free/', '');
+                    isEnterprise = false;
+                    isFallbackActive = true;
+                    fallbackReason = "Daily Tier Empty (Wallet Protected)";
+                }
+            }
+        }
+        else if (config.mode === 'pro') {
+            if (isEnterprise) {
+                if (quota.tier === 'error') {
+                    log(`[SafetyNet] Pro Mode: Quota Unreachable. Switching to Free Fallback.`);
+                    actualModel = config.fallbacks.free.main.replace('free/', '');
+                    isEnterprise = false;
+                    isFallbackActive = true;
+                    fallbackReason = "Quota Unreachable (Safety)";
+                }
+                else if (quota.walletBalance < 0.10 && quota.tierRemaining <= 0.1) {
+                    log(`[SafetyNet] Pro Mode: Wallet Critical (<$0.10). Switching to Free Fallback.`);
+                    actualModel = config.fallbacks.free.main.replace('free/', '');
+                    isEnterprise = false;
+                    isFallbackActive = true;
+                    fallbackReason = "Wallet Critical";
+                }
+            }
+        }
+        // C. Construct URL & Headers
+        if (isEnterprise) {
+            if (!config.apiKey) {
+                emitLogToast('error', "Missing API Key for Enterprise Model", 'Proxy Error');
+                res.writeHead(401, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: { message: "API Key required for Enterprise models." } }));
+                return;
+            }
+            targetUrl = 'https://gen.pollinations.ai/v1/chat/completions';
+            authHeader = `Bearer ${config.apiKey}`;
+            log(`Routing to ENTERPRISE: ${actualModel}`);
+        }
+        else {
+            targetUrl = 'https://text.pollinations.ai/openai/chat/completions';
+            authHeader = undefined;
+            log(`Routing to FREE: ${actualModel} ${isFallbackActive ? '(FALLBACK)' : ''}`);
+            emitLogToast('info', `Routing to: FREE UNIVERSE (${actualModel})`, 'Pollinations Routing');
+        }
+        // NOTIFY SWITCH
+        if (isFallbackActive) {
+            emitStatusToast('warning', `⚠️ Safety Net: ${actualModel} (${fallbackReason})`, 'Pollinations Safety');
+        }
+        // 2. Prepare Proxy Body
+        const proxyBody = {
+            ...body,
+            model: actualModel
+        };
+        // 3. Global Hygiene
+        if (!isEnterprise && !proxyBody.seed) {
+            proxyBody.seed = Math.floor(Math.random() * 1000000);
+        }
+        if (isEnterprise)
+            proxyBody.private = true;
+        if (proxyBody.stream_options)
+            delete proxyBody.stream_options;
+        // 3.6 STOP SEQUENCES (Prevent Looping - CRITICAL FIX)
+        // Inject explicit stop sequences to prevent "User:" hallucinations
+        if (!proxyBody.stop) {
+            proxyBody.stop = ["\nUser:", "\nModel:", "User:", "Model:"];
+        }
+        // 3.5 PREPARE SIGNATURE HASHING
+        let currentRequestHash = null;
+        if (proxyBody.messages && proxyBody.messages.length > 0) {
+            const lastMsg = proxyBody.messages[proxyBody.messages.length - 1];
+            currentRequestHash = hashMessage(lastMsg);
+        }
+        // =========================================================
+        // LOGIC BLOCK: MODEL SPECIFIC ADAPTATIONS
+        // =========================================================
+        if (proxyBody.tools && Array.isArray(proxyBody.tools)) {
+            // B0. KIMI / MOONSHOT SURGICAL FIX (Restored for Debug)
+            // Tools are ENABLED. We rely on penalties and strict stops to fight loops.
+            if (actualModel.includes("kimi") || actualModel.includes("moonshot")) {
+                log(`[Proxy] Kimi: Tools ENABLED. Applying penalties/stops.`);
+                proxyBody.frequency_penalty = 1.1;
+                proxyBody.presence_penalty = 0.4;
+                proxyBody.stop = ["<|endoftext|>", "User:", "\nUser", "User :"];
+            }
+            // A. AZURE/OPENAI FIXES
+            if (actualModel.includes("gpt") || actualModel.includes("openai") || actualModel.includes("azure")) {
+                proxyBody.tools = truncateTools(proxyBody.tools, 120);
+                if (proxyBody.messages) {
+                    proxyBody.messages.forEach((m) => {
+                        if (m.tool_calls) {
+                            m.tool_calls.forEach((tc) => {
+                                if (tc.id && tc.id.length > 40)
+                                    tc.id = tc.id.substring(0, 40);
+                            });
+                        }
+                        if (m.tool_call_id && m.tool_call_id.length > 40) {
+                            m.tool_call_id = m.tool_call_id.substring(0, 40);
+                        }
+                    });
+                }
+            }
+            // B1. NOMNOM SPECIAL (Disable Grounding, KEEP Search Tool)
+            if (actualModel === "nomnom") {
+                proxyBody.tools_config = { google_search_retrieval: { disable: true } };
+                // Keep Tools, Just Sanitize
+                proxyBody.tools = sanitizeToolsForVertex(proxyBody.tools || []);
+                log(`[Proxy] Nomnom Fix: Grounding Disabled, Search Tool KEPT.`);
+            }
+            // B2. GEMINI FREE / FAST (CRASH FIX: STRICT SANITIZATION)
+            // Restore Tools but REMOVE conflicting ones (Search)
+            else if ((actualModel.includes("gemini") && !isEnterprise) ||
+                (actualModel.includes("gemini") && actualModel.includes("fast"))) {
+                const hasFunctions = proxyBody.tools.some((t) => t.type === 'function' || t.function);
+                if (hasFunctions) {
+                    // 1. Disable Magic Grounding (Source of loops/crashes)
+                    proxyBody.tools_config = { google_search_retrieval: { disable: true } };
+                    // 2. Remove 'google_search' explicitly (Replica of V3.5.5 logic)
+                    proxyBody.tools = proxyBody.tools.filter((t) => {
+                        const isFunc = t.type === 'function' || t.function;
+                        const name = t.function?.name || t.name;
+                        return isFunc && name !== 'google_search';
+                    });
+                    // 3. Ensure tools are Vertex-Compatible
+                    proxyBody.tools = sanitizeToolsForVertex(proxyBody.tools);
+                    log(`[Proxy] Gemini Free: Tools RESTORED but Sanitized (No Search/Grounding).`);
+                }
+            }
+            // B3. GEMINI ENTERPRISE 3.0+
+            else if (actualModel.includes("gemini")) {
+                const hasFunctions = proxyBody.tools.some((t) => t.type === 'function' || t.function);
+                if (hasFunctions) {
+                    proxyBody.tools_config = { google_search_retrieval: { disable: true } };
+                    // Keep Search Tool in List
+                    proxyBody.tools = proxyBody.tools.filter((t) => t.type === 'function' || t.function);
+                    proxyBody.tools = sanitizeToolsForVertex(proxyBody.tools);
+                }
+            }
+        }
+        // C. GEMINI ID BACKTRACKING & SIGNATURE
+        if ((actualModel.includes("gemini") || actualModel === "nomnom") && proxyBody.messages) {
+            const lastMsg = proxyBody.messages[proxyBody.messages.length - 1];
+            proxyBody.messages.forEach((m, index) => {
+                if (m.role === 'assistant') {
+                    let sig = null;
+                    if (index > 0) {
+                        const prevMsg = proxyBody.messages[index - 1];
+                        const prevHash = hashMessage(prevMsg);
+                        sig = signatureMap[prevHash];
+                    }
+                    if (!sig)
+                        sig = lastSignature;
+                    if (sig) {
+                        if (!m.thought_signature)
+                            m.thought_signature = sig;
+                        if (m.tool_calls) {
+                            m.tool_calls.forEach((tc) => {
+                                if (!tc.thought_signature)
+                                    tc.thought_signature = sig;
+                                if (tc.function && !tc.function.thought_signature)
+                                    tc.function.thought_signature = sig;
+                            });
+                        }
+                    }
+                }
+                else if (m.role === 'tool') {
+                    let sig = null;
+                    if (index > 0)
+                        sig = lastSignature; // Fallback
+                    if (sig && !m.thought_signature) {
+                        m.thought_signature = sig;
+                    }
+                }
+            });
+            // Fix Tool Response ID
+            if (lastMsg.role === 'tool') {
+                let targetAssistantMsg = null;
+                for (let i = proxyBody.messages.length - 2; i >= 0; i--) {
+                    const m = proxyBody.messages[i];
+                    if (m.role === 'assistant' && m.tool_calls && m.tool_calls.length > 0) {
+                        targetAssistantMsg = m;
+                        break;
+                    }
+                }
+                if (targetAssistantMsg) {
+                    const originalId = targetAssistantMsg.tool_calls[0].id;
+                    const currentId = lastMsg.tool_call_id;
+                    if (currentId !== originalId) {
+                        lastMsg.tool_call_id = originalId;
+                    }
+                }
+            }
+        }
+        // 4. Headers
+        const headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json, text/event-stream',
+            'User-Agent': 'curl/8.5.0'
+        };
+        if (authHeader)
+            headers['Authorization'] = authHeader;
+        // 5. Forward (Global Fetch with Retry)
+        const fetchRes = await fetchWithRetry(targetUrl, {
+            method: 'POST',
+            headers: headers,
+            body: JSON.stringify(proxyBody)
+        });
+        res.statusCode = fetchRes.status;
+        fetchRes.headers.forEach((val, key) => {
+            if (key !== 'content-encoding' && key !== 'content-length') {
+                res.setHeader(key, val);
+            }
+        });
+        if (!fetchRes.ok) {
+            log(`Upstream Error: ${fetchRes.status} ${fetchRes.statusText}`);
+            // TRANSPARENT FALLBACK ON 402 (Payment) or 429 (Rate Limit) IF Enterprise
+            if ((fetchRes.status === 402 || fetchRes.status === 429) && isEnterprise) {
+                log(`[SafetyNet] Upstream Rejection (${fetchRes.status}). Triggering Transparent Fallback.`);
+                // 1. Switch Config
+                actualModel = config.fallbacks.free.main.replace('free/', '');
+                isEnterprise = false;
+                isFallbackActive = true;
+                fallbackReason = fetchRes.status === 402 ? "Insufficient Funds (Upstream 402)" : "Rate Limit (Upstream 429)";
+                // 2. Notify
+                emitStatusToast('warning', `⚠️ Safety Net: ${actualModel} (${fallbackReason})`, 'Pollinations Safety');
+                emitLogToast('warning', `Recovering from ${fetchRes.status} -> Switching to ${actualModel}`, 'Safety Net');
+                // 3. Re-Prepare Request
+                targetUrl = 'https://text.pollinations.ai/openai/chat/completions';
+                const retryHeaders = { ...headers };
+                delete retryHeaders['Authorization']; // Free = No Auth
+                const retryBody = { ...proxyBody, model: actualModel };
+                // 4. Retry Fetch
+                const retryRes = await fetchWithRetry(targetUrl, {
+                    method: 'POST',
+                    headers: retryHeaders,
+                    body: JSON.stringify(retryBody)
+                });
+                if (retryRes.ok) {
+                    res.statusCode = retryRes.status;
+                    // Overwrite response with retry
+                    // We need to handle the stream of retryRes now.
+                    // The easiest way is to assign fetchRes = retryRes, BUT fetchRes is const.
+                    // Refactor needed? No, I can just stream retryRes here and return.
+                    retryRes.headers.forEach((val, key) => {
+                        if (key !== 'content-encoding' && key !== 'content-length') {
+                            res.setHeader(key, val);
+                        }
+                    });
+                    if (retryRes.body) {
+                        let accumulated = "";
+                        let currentSignature = null;
+                        // @ts-ignore
+                        for await (const chunk of retryRes.body) {
+                            const buffer = Buffer.from(chunk);
+                            const chunkStr = buffer.toString();
+                            // ... (Copy basic stream logic or genericize? Copying safe for hotfix)
+                            accumulated += chunkStr;
+                            res.write(chunkStr);
+                        }
+                        // INJECT NOTIFICATION AT END
+                        const warningMsg = `\n\n> ⚠️ **Safety Net**: ${fallbackReason}. Switched to \`${actualModel}\`.`;
+                        const safeId = "fallback-" + Date.now();
+                        const warningChunk = {
+                            id: safeId,
+                            object: "chat.completion.chunk",
+                            created: Math.floor(Date.now() / 1000),
+                            model: actualModel,
+                            choices: [{ index: 0, delta: { role: "assistant", content: warningMsg }, finish_reason: null }]
+                        };
+                        res.write(`data: ${JSON.stringify(warningChunk)}\n\n`);
+                        // DASHBOARD UPDATE
+                        const dashboardMsg = formatQuotaForToast(quota); // Quota is stale/empty but that's fine
+                        const fullMsg = `${dashboardMsg} | ⚙️ PRO (FALLBACK)`;
+                        emitStatusToast('info', fullMsg, 'Pollinations Status');
+                        res.end();
+                        return; // EXIT FUNCTION, HANDLED.
+                    }
+                }
+            }
+        }
+        // Stream Loop
+        if (fetchRes.body) {
+            let accumulated = "";
+            let currentSignature = null;
+            // @ts-ignore
+            for await (const chunk of fetchRes.body) {
+                const buffer = Buffer.from(chunk);
+                let chunkStr = buffer.toString();
+                // FIX: STOP REASON NORMALIZATION using Regex Safely
+                // 1. If Kimi/Model sends "tool_calls" reason but "tool_calls":null, FORCE STOP.
+                if (chunkStr.includes('"finish_reason": "tool_calls"') && chunkStr.includes('"tool_calls":null')) {
+                    chunkStr = chunkStr.replace('"finish_reason": "tool_calls"', '"finish_reason": "stop"');
+                }
+                // 2. Original Logic: Ensure formatting but avoid false positives on null
+                // Only upgrade valid stops to tool_calls if we see actual tool array start
+                if (chunkStr.includes('"finish_reason"')) {
+                    const stopRegex = /"finish_reason"\s*:\s*"(stop|STOP|did_not_finish|finished|end_turn|MAX_TOKENS)"/g;
+                    if (stopRegex.test(chunkStr)) {
+                        if (chunkStr.includes('"tool_calls":[') || chunkStr.includes('"tool_calls": [')) {
+                            chunkStr = chunkStr.replace(stopRegex, '"finish_reason": "tool_calls"');
+                        }
+                        else {
+                            chunkStr = chunkStr.replace(stopRegex, '"finish_reason": "stop"');
+                        }
+                    }
+                }
+                // SIGNATURE CAPTURE
+                if (!currentSignature) {
+                    const match = chunkStr.match(/"thought_signature"\s*:\s*"([^"]+)"/);
+                    if (match && match[1])
+                        currentSignature = match[1];
+                }
+                // SAFETY STOP: SERVER-SIDE LOOP DETECTION (GUILLOTINE)
+                if (chunkStr.includes("User:") || chunkStr.includes("\nUser") || chunkStr.includes("user:")) {
+                    if (chunkStr.match(/(\n|^)\s*(User|user)\s*:/)) {
+                        res.end();
+                        return; // HARD STOP
+                    }
+                }
+                accumulated += chunkStr;
+                res.write(chunkStr);
+            }
+            // INJECT NOTIFICATION AT END
+            if (isFallbackActive) {
+                const warningMsg = `\n\n> ⚠️ **Safety Net**: ${fallbackReason}. Switched to \`${actualModel}\`.`;
+                const safeId = "fallback-" + Date.now();
+                const warningChunk = {
+                    id: safeId,
+                    object: "chat.completion.chunk",
+                    created: Math.floor(Date.now() / 1000),
+                    model: actualModel,
+                    choices: [{ index: 0, delta: { role: "assistant", content: warningMsg }, finish_reason: null }]
+                };
+                res.write(`data: ${JSON.stringify(warningChunk)}\n\n`);
+            }
+            // END STREAM: SAVE MAP & EMIT TOAST
+            if (currentSignature && currentRequestHash) {
+                signatureMap[currentRequestHash] = currentSignature;
+                saveSignatureMap();
+                lastSignature = currentSignature;
+            }
+            // V5 DASHBOARD TOAST
+            const dashboardMsg = formatQuotaForToast(quota);
+            let modeLabel = config.mode.toUpperCase();
+            if (isFallbackActive)
+                modeLabel += " (FALLBACK)";
+            const fullMsg = `${dashboardMsg} | ⚙️ ${modeLabel}`;
+            // Only emit if not silenced (handled inside emitStatusToast)
+            emitStatusToast('info', fullMsg, 'Pollinations Status');
+        }
+        res.end();
+    }
+    catch (e) {
+        log(`ERROR: Proxy Handler Error: ${String(e)}`);
+        if (!res.headersSent) {
+            res.writeHead(500);
+            res.end(JSON.stringify({ error: "Internal Proxy Error", details: String(e) }));
+        }
+    }
+}

package/dist/server/quota.d.ts

@@ -0,0 +1,15 @@
+export interface QuotaStatus {
+    tierRemaining: number;
+    tierUsed: number;
+    tierLimit: number;
+    walletBalance: number;
+    nextResetAt: Date;
+    timeUntilReset: number;
+    canUseEnterprise: boolean;
+    isUsingWallet: boolean;
+    needsAlert: boolean;
+    tier: string;
+    tierEmoji: string;
+}
+export declare function getQuotaStatus(forceRefresh?: boolean): Promise<QuotaStatus>;
+export declare function formatQuotaForToast(quota: QuotaStatus): string;