opencode-pollinations-plugin 6.0.0 → 6.1.0-beta.10

package/dist/server/proxy.js

@@ -78,6 +78,23 @@ function dereferenceSchema(schema, rootDefs) {
             schema.description = (schema.description || "") + " [Ref Failed]";
         }
     }
+    // VERTEX FIX: 'const' not supported -> convert to 'enum'
+    if (schema.const !== undefined) {
+        schema.enum = [schema.const];
+        delete schema.const;
+    }
+    // VERTEX FIX: 'anyOf' must be exclusive (no other siblings)
+    if (schema.anyOf || schema.oneOf) {
+        // Vertex demands strict exclusivity.
+        // We keep 'definitions'/'$defs' if present at root (though unlikely here)
+        // But for a property node, we must strip EVERYTHING else.
+        const keys = Object.keys(schema);
+        keys.forEach(k => {
+            if (k !== 'anyOf' && k !== 'oneOf' && k !== 'definitions' && k !== '$defs') {
+                delete schema[k];
+            }
+        });
+    }
     if (schema.properties) {
         for (const key in schema.properties) {
             schema.properties[key] = dereferenceSchema(schema.properties[key], rootDefs);
@@ -86,6 +103,15 @@ function dereferenceSchema(schema, rootDefs) {
     if (schema.items) {
         schema.items = dereferenceSchema(schema.items, rootDefs);
     }
+    if (schema.anyOf) {
+        schema.anyOf = schema.anyOf.map((s) => dereferenceSchema(s, rootDefs));
+    }
+    if (schema.oneOf) {
+        schema.oneOf = schema.oneOf.map((s) => dereferenceSchema(s, rootDefs));
+    }
+    if (schema.allOf) {
+        schema.allOf = schema.allOf.map((s) => dereferenceSchema(s, rootDefs));
+    }
     if (schema.optional !== undefined)
         delete schema.optional;
     if (schema.title)
@@ -107,6 +133,38 @@ function sanitizeToolsForVertex(tools) {
         return tool;
     });
 }
+function sanitizeToolsForBedrock(tools) {
+    return tools.map(tool => {
+        if (tool.function) {
+            if (!tool.function.description || tool.function.description.length === 0) {
+                tool.function.description = " "; // Force non-empty string
+            }
+        }
+        return tool;
+    });
+}
+function sanitizeSchemaForKimi(schema) {
+    if (!schema || typeof schema !== 'object')
+        return schema;
+    // Kimi Fixes
+    if (schema.title)
+        delete schema.title;
+    // Fix empty objects "{}" which Kimi hates.
+    // If it's an empty object without type, assume string or object?
+    // Often happens with "additionalProperties: {}"
+    if (Object.keys(schema).length === 0) {
+        schema.type = "string"; // Fallback to safe type
+        schema.description = "Any value";
+    }
+    if (schema.properties) {
+        for (const key in schema.properties) {
+            schema.properties[key] = sanitizeSchemaForKimi(schema.properties[key]);
+        }
+    }
+    if (schema.items)
+        sanitizeSchemaForKimi(schema.items);
+    return schema;
+}
 function truncateTools(tools, limit = 120) {
     if (!tools || tools.length <= limit)
         return tools;
@@ -114,12 +172,16 @@ function truncateTools(tools, limit = 120) {
 }
 const MAX_RETRIES = 3;
 const RETRY_DELAY_MS = 1000;
+const FETCH_TIMEOUT_MS = 600000; // 10 Minutes global timeout
 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);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        const response = await fetch(url, { ...options, signal: controller.signal });
+        clearTimeout(timeoutId);
         if (response.ok)
             return response;
         if (response.status === 404 || response.status === 401 || response.status === 400) {
@@ -153,11 +215,6 @@ export async function handleChatCompletion(req, res, bodyRaw) {
         const config = loadConfig();
         // DEBUG: Trace Config State for Hot Reload verification
         log(`[Proxy Request] Config Loaded. Mode: ${config.mode}, HasKey: ${!!config.apiKey}, KeyLength: ${config.apiKey ? config.apiKey.length : 0}`);
-        // SPY LOGGING
-        try {
-            fs.appendFileSync('/tmp/opencode_spy.log', `\n\n=== REQUEST ${new Date().toISOString()} ===\nMODEL: ${body.model}\nBODY:\n${JSON.stringify(body, null, 2)}\n==========================\n`);
-        }
-        catch (e) { }
         // 0. COMMAND HANDLING
         if (body.messages && body.messages.length > 0) {
             const lastMsg = body.messages[body.messages.length - 1];
@@ -208,6 +265,27 @@ export async function handleChatCompletion(req, res, bodyRaw) {
             }
         }
         log(`Incoming Model (OpenCode ID): ${body.model}`);
+        // 0. SPECIAL: connect-pollinations fallback model
+        if (body.model === 'connect-pollinations') {
+            const connectMsg = {
+                id: `chatcmpl-connect-${Date.now()}`,
+                object: 'chat.completion',
+                created: Math.floor(Date.now() / 1000),
+                model: 'connect-pollinations',
+                choices: [{
+                        index: 0,
+                        message: {
+                            role: 'assistant',
+                            content: `🔗 **Se connecter à Pollinations**\n\nAccédez à 30+ modèles IA de pointe !\n\n📍 **Étapes :**\n1. Visitez https://enter.pollinations.ai\n2. Créez un compte gratuit\n3. Copiez votre API Key\n4. Exécutez: \`/pollinations config apiKey YOUR_KEY\`\n5. Redémarrez OpenCode\n\n✅ **Bénéfices :**\n• 30+ modèles avancés (GPT-5, Claude, Gemini...)\n• Crédits gratuits selon votre tier\n• Stabilité garantie`
+                        },
+                        finish_reason: 'stop'
+                    }],
+                usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+            };
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(connectMsg));
+            return;
+        }
         // 1. STRICT ROUTING & SAFETY NET LOGIC (V5)
         let actualModel = body.model || "openai";
         let isEnterprise = false;
@@ -216,16 +294,15 @@ export async function handleChatCompletion(req, res, bodyRaw) {
         // LOAD QUOTA FOR SAFETY CHECKS
         const { getQuotaStatus, formatQuotaForToast } = await import('./quota.js');
         const quota = await getQuotaStatus(false);
-        // A. Resolve Base Target - v6.0: All models go to gen.pollinations.ai
-        // Strip any legacy prefixes for backwards compatibility
-        if (actualModel.startsWith('enter/') || actualModel.startsWith('enter-')) {
-            actualModel = actualModel.replace(/^enter[-/]/, '');
+        // A. Resolve Base Target
+        if (actualModel.startsWith('enter/')) {
+            isEnterprise = true;
+            actualModel = actualModel.replace('enter/', '');
         }
-        else if (actualModel.startsWith('free/') || actualModel.startsWith('free-')) {
-            actualModel = actualModel.replace(/^free[-/]/, '');
+        else if (actualModel.startsWith('free/')) {
+            isEnterprise = false;
+            actualModel = actualModel.replace('free/', '');
         }
-        // v6.0: Everything is enterprise now (requires API key)
-        isEnterprise = true;
         // A.1 PAID MODEL ENFORCEMENT (V5.5 Strategy)
         // Check dynamic list saved by generate-config.ts
         if (isEnterprise) {
@@ -279,18 +356,33 @@ export async function handleChatCompletion(req, res, bodyRaw) {
         }
         if (config.mode === 'alwaysfree') {
             if (isEnterprise) {
-                // NEW: Paid Only Check for Always Free
+                // Paid Only Check: BLOCK (not fallback) in AlwaysFree mode
                 try {
                     const homedir = process.env.HOME || '/tmp';
                     const standardPaidPath = path.join(homedir, '.pollinations', 'pollinations-paid-models.json');
                     if (fs.existsSync(standardPaidPath)) {
                         const paidModels = JSON.parse(fs.readFileSync(standardPaidPath, 'utf-8'));
                         if (paidModels.includes(actualModel)) {
-                            log(`[SafetyNet] alwaysfree Mode: Request for Paid Only Model (${actualModel}). FALLBACK.`);
-                            actualModel = config.fallbacks.free.main.replace('free/', '');
-                            isEnterprise = false;
-                            isFallbackActive = true;
-                            fallbackReason = "Mode AlwaysFree actif: Ce modèle payant consomme du wallet. Passez en mode PRO.";
+                            log(`[AlwaysFree] BLOCKED: Paid Only Model (${actualModel}).`);
+                            emitStatusToast('warning', `🚫 Modèle payant bloqué: ${actualModel}`, 'AlwaysFree Mode');
+                            const blockMsg = {
+                                id: `chatcmpl-block-${Date.now()}`,
+                                object: 'chat.completion',
+                                created: Math.floor(Date.now() / 1000),
+                                model: actualModel,
+                                choices: [{
+                                        index: 0,
+                                        message: {
+                                            role: 'assistant',
+                                            content: `🚫 **Modèle payant non disponible en mode AlwaysFree**\n\nLe modèle \`${actualModel}\` consomme directement votre wallet (💎 Paid Only).\n\n**Solutions :**\n• \`/pollinations config mode pro\` — Autorise les modèles payants avec protection wallet\n• \`/pollinations config mode manual\` — Aucune restriction, contrôle total`
+                                        },
+                                        finish_reason: 'stop'
+                                    }],
+                                usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+                            };
+                            res.writeHead(200, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify(blockMsg));
+                            return;
                         }
                     }
                 }
@@ -337,16 +429,24 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                 }
             }
         }
-        // C. Construct URL & Headers - v6.0: Always gen.pollinations.ai
-        if (!config.apiKey) {
-            emitLogToast('error', "Missing API Key - Use /pollinations connect <key>", 'Proxy Error');
-            res.writeHead(401, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: { message: "API Key required. Use /pollinations connect <your_key> to connect." } }));
-            return;
+        // 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'); // Too noisy
         }
-        targetUrl = 'https://gen.pollinations.ai/v1/chat/completions';
-        authHeader = `Bearer ${config.apiKey}`;
-        log(`Routing to gen.pollinations.ai: ${actualModel}`);
         // NOTIFY SWITCH
         if (isFallbackActive) {
             emitStatusToast('warning', `⚠️ Safety Net: ${actualModel} (${fallbackReason})`, 'Pollinations Safety');
@@ -378,17 +478,24 @@ export async function handleChatCompletion(req, res, bodyRaw) {
         // LOGIC BLOCK: MODEL SPECIFIC ADAPTATIONS
         // =========================================================
         if (proxyBody.tools && Array.isArray(proxyBody.tools) && proxyBody.tools.length > 0) {
-            // B0. KIMI / MOONSHOT SURGICAL FIX (Restored for Debug)
-            // Tools are ENABLED. We rely on penalties and strict stops to fight loops.
+            // B0. KIMI / MOONSHOT SURGICAL FIX
             if (actualModel.includes("kimi") || actualModel.includes("moonshot")) {
-                log(`[Proxy] Kimi: Tools ENABLED. Applying penalties/stops.`);
+                log(`[Proxy] Kimi: Tools ENABLED. Applying penalties/stops/sanitization.`);
                 proxyBody.frequency_penalty = 1.1;
                 proxyBody.presence_penalty = 0.4;
                 proxyBody.stop = ["<|endoftext|>", "User:", "\nUser", "User :"];
+                // KIMI FIX: Remove 'title' from schema
+                proxyBody.tools = proxyBody.tools.map((t) => {
+                    if (t.function && t.function.parameters) {
+                        t.function.parameters = sanitizeSchemaForKimi(t.function.parameters);
+                    }
+                    return t;
+                });
             }
-            // A. AZURE/OPENAI FIXES
-            if (actualModel.includes("gpt") || actualModel.includes("openai") || actualModel.includes("azure")) {
-                proxyBody.tools = truncateTools(proxyBody.tools, 120);
+            // A. AZURE/OPENAI FIXES + MIDJOURNEY + GROK
+            if (actualModel.includes("gpt") || actualModel.includes("openai") || actualModel.includes("azure") || actualModel.includes("midijourney") || actualModel.includes("grok")) {
+                const limit = (actualModel.includes("midijourney") || actualModel.includes("grok")) ? 128 : 120;
+                proxyBody.tools = truncateTools(proxyBody.tools, limit);
                 if (proxyBody.messages) {
                     proxyBody.messages.forEach((m) => {
                         if (m.tool_calls) {
@@ -403,6 +510,11 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                     });
                 }
             }
+            // BEDROCK FIX (Claude / Nova / ChickyTutor)
+            if (actualModel.includes("claude") || actualModel.includes("nova") || actualModel.includes("bedrock") || actualModel.includes("chickytutor")) {
+                log(`[Proxy] Bedrock: Sanitizing tools description.`);
+                proxyBody.tools = sanitizeToolsForBedrock(proxyBody.tools);
+            }
             // B1. NOMNOM SPECIAL (Disable Grounding, KEEP Search Tool)
             if (actualModel === "nomnom") {
                 proxyBody.tools_config = { google_search_retrieval: { disable: true } };
@@ -410,36 +522,12 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                 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)
             // B. GEMINI UNIFIED FIX (Free, Fast, Pro, Enterprise, Legacy)
-            // Handles: "tools" vs "grounding" conflicts, and "infinite loops" via Stop Sequences.
-            // GLOBAL BEDROCK FIX (All Models)
-            // Check if history has tools but current request misses tools definition.
-            // This happens when OpenCode sends the Tool Result (optimisation),
-            // but Bedrock requires toolConfig to validate the history.
-            const hasToolHistory = proxyBody.messages?.some((m) => m.role === 'tool' || m.tool_calls);
-            if (hasToolHistory && (!proxyBody.tools || proxyBody.tools.length === 0)) {
-                // Inject Shim Tool to satisfy Bedrock
-                proxyBody.tools = [{
-                        type: 'function',
-                        function: {
-                            name: '_bedrock_compatibility_shim',
-                            description: 'Internal system tool to satisfy Bedrock strict toolConfig requirement. Do not use.',
-                            parameters: { type: 'object', properties: {} }
-                        }
-                    }];
-                log(`[Proxy] Bedrock Fix: Injected shim tool for ${actualModel} (History has tools, Request missing tools)`);
-            }
-            // B. GEMINI UNIFIED FIX (Free, Fast, Pro, Enterprise, Legacy)
-            // Fixes "Multiple tools" error (Vertex) and "JSON body validation failed" (v5.3.5 regression)
-            // Added ChickyTutor (Claude/Gemini based) to fix "toolConfig must be defined" error.
-            else if (actualModel.includes("gemini") || actualModel.includes("chickytutor")) {
+            else if (actualModel.includes("gemini")) {
                 let hasFunctions = false;
                 if (proxyBody.tools && Array.isArray(proxyBody.tools)) {
                     hasFunctions = proxyBody.tools.some((t) => t.type === 'function' || t.function);
                 }
-                // Old Shim logic removed (moved up)
                 if (hasFunctions) {
                     // 1. Strict cleanup of 'google_search' tool
                     proxyBody.tools = proxyBody.tools.filter((t) => {
@@ -470,14 +558,6 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                 log(`[Proxy] Gemini Logic: Tools=${proxyBody.tools ? proxyBody.tools.length : 'REMOVED'}, Stops NOT Injected.`);
             }
         }
-        // B5. BEDROCK TOKEN LIMIT FIX
-        if (actualModel.includes("chicky") || actualModel.includes("mistral")) {
-            // Force max_tokens if not present or too high (Bedrock outputs usually max 4k, context 8k+ but strict check)
-            if (!proxyBody.max_tokens || proxyBody.max_tokens > 4096) {
-                proxyBody.max_tokens = 4096;
-                log(`[Proxy] Enforcing max_tokens=4096 for ${actualModel} (Bedrock Limit)`);
-            }
-        }
         // C. GEMINI ID BACKTRACKING & SIGNATURE
         if ((actualModel.includes("gemini") || actualModel === "nomnom") && proxyBody.messages) {
             const lastMsg = proxyBody.messages[proxyBody.messages.length - 1];
@@ -567,8 +647,14 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                     actualModel = config.fallbacks.free.main.replace('free/', '');
                     isEnterprise = false;
                     isFallbackActive = true;
-                    if (fetchRes.status === 402)
+                    if (fetchRes.status === 402) {
                         fallbackReason = "Insufficient Funds (Upstream 402)";
+                        // Force refresh quota cache so next pre-flight check is accurate
+                        try {
+                            await getQuotaStatus(true);
+                        }
+                        catch (e) { }
+                    }
                     else if (fetchRes.status === 429)
                         fallbackReason = "Rate Limit (Upstream 429)";
                     else if (fetchRes.status === 401)
@@ -586,10 +672,10 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                 // 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 - v6.0: Stay on gen.pollinations.ai
-                targetUrl = 'https://gen.pollinations.ai/v1/chat/completions';
+                // 3. Re-Prepare Request
+                targetUrl = 'https://text.pollinations.ai/openai/chat/completions';
                 const retryHeaders = { ...headers };
-                // Keep Authorization for gen.pollinations.ai
+                delete retryHeaders['Authorization']; // Free = No Auth
                 const retryBody = { ...proxyBody, model: actualModel };
                 // 4. Retry Fetch
                 const retryRes = await fetchWithRetry(targetUrl, {

package/dist/server/quota.d.ts

@@ -1,3 +1,11 @@
+export interface DetailedUsageEntry {
+    timestamp: string;
+    type: string;
+    model: string;
+    meter_source: 'tier' | 'pack';
+    cost_usd: number;
+    requests?: number;
+}
 export interface QuotaStatus {
     tierRemaining: number;
     tierUsed: number;

package/dist/server/quota.js

@@ -1,12 +1,17 @@
 import * as fs from 'fs';
+import * as path from 'path';
 import * as https from 'https'; // Use Native HTTPS
+import * as crypto from 'crypto';
 import { loadConfig } from './config.js';
-// === CACHE ===
+// === CACHE & CONSTANTS ===
 const CACHE_TTL = 30000; // 30 secondes
 let cachedQuota = null;
 let lastQuotaFetch = 0;
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+const HISTORY_RETENTION_MS = 48 * 60 * 60 * 1000; // 48h history
 // === TIER LIMITS ===
 const TIER_LIMITS = {
+    microbe: { pollen: 0.1, emoji: '🦠' },
     spore: { pollen: 1, emoji: '🦠' },
     seed: { pollen: 3, emoji: '🌱' },
     flower: { pollen: 10, emoji: '🌸' },
@@ -19,24 +24,71 @@ function logQuota(msg) {
     }
     catch (e) { }
 }
-// === FONCTIONS PRINCIPALES ===
+// === HISTORY MANAGER (JSON) ===
+function getHistoryFilePath() {
+    const homedir = process.env.HOME || '/tmp';
+    const historyDir = path.join(homedir, '.pollinations');
+    if (!fs.existsSync(historyDir)) {
+        try {
+            fs.mkdirSync(historyDir, { recursive: true });
+        }
+        catch (e) { }
+    }
+    return path.join(historyDir, 'usage_history.json');
+}
+function computeEntrySignature(entry) {
+    // Unique signature per transaction: timestamp + model + cost + source
+    return crypto.createHash('md5').update(`${entry.timestamp}|${entry.model}|${entry.cost_usd}|${entry.meter_source}`).digest('hex');
+}
+function updateLocalHistory(newEntries) {
+    const filePath = getHistoryFilePath();
+    let history = [];
+    // 1. Load existing
+    try {
+        if (fs.existsSync(filePath)) {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            history = JSON.parse(raw);
+        }
+    }
+    catch (e) {
+        logQuota(`Failed to load history: ${e}`);
+        history = [];
+    }
+    // 2. Merge (Deduplication via Signature)
+    const existingSignatures = new Set(history.map(computeEntrySignature));
+    let addedCount = 0;
+    for (const entry of newEntries) {
+        const sig = computeEntrySignature(entry);
+        if (!existingSignatures.has(sig)) {
+            history.push(entry);
+            existingSignatures.add(sig);
+            addedCount++;
+        }
+    }
+    // 3. Prune (> 48h)
+    const now = Date.now();
+    const beforePrune = history.length;
+    history = history.filter(e => {
+        const entryTime = new Date(e.timestamp.replace(' ', 'T') + 'Z').getTime();
+        return (now - entryTime) < HISTORY_RETENTION_MS;
+    });
+    // 4. Sort (Newest first)
+    history.sort((a, b) => new Date(b.timestamp.replace(' ', 'T') + 'Z').getTime() - new Date(a.timestamp.replace(' ', 'T') + 'Z').getTime());
+    // 5. Save
+    try {
+        fs.writeFileSync(filePath, JSON.stringify(history, null, 2));
+        logQuota(`History Update: Added ${addedCount}, Pruned ${beforePrune - history.length}, Total ${history.length} entries.`);
+    }
+    catch (e) {
+        logQuota(`Failed to save history: ${e}`);
+    }
+    return history;
+}
+// === MAIN QUOTA FUNCTION ===
 export async function getQuotaStatus(forceRefresh = false) {
     const config = loadConfig();
     if (!config.apiKey) {
-        // Pas de clé = Mode manual par défaut, pas de quota
-        return {
-            tierRemaining: 0,
-            tierUsed: 0,
-            tierLimit: 0,
-            walletBalance: 0,
-            nextResetAt: new Date(),
-            timeUntilReset: 0,
-            canUseEnterprise: false,
-            isUsingWallet: false,
-            needsAlert: false,
-            tier: 'none',
-            tierEmoji: '❌'
-        };
+        return createDefaultQuota('none', 0);
     }
     const now = Date.now();
     if (!forceRefresh && cachedQuota && (now - lastQuotaFetch) < CACHE_TTL) {
@@ -44,27 +96,33 @@ export async function getQuotaStatus(forceRefresh = false) {
     }
     try {
         logQuota("Fetching Quota Data...");
+        // 1. Fetch API
         // SEQUENTIAL FETCH (Avoid Rate Limits)
-        // We fetch one by one. If one fails, we catch and return fallback.
         const profileRes = await fetchAPI('/account/profile', config.apiKey);
         const balanceRes = await fetchAPI('/account/balance', config.apiKey);
         const usageRes = await fetchAPI('/account/usage', config.apiKey);
         logQuota(`Fetch Success. Tier: ${profileRes.tier}, Balance: ${balanceRes.balance}`);
         const profile = profileRes;
         const balance = balanceRes.balance;
-        const usage = usageRes.usage || [];
-        const tierInfo = TIER_LIMITS[profile.tier] || { pollen: 1, emoji: '❓' }; // Default 1 (Spore)
+        // 2. Update Local History (The Source of Truth)
+        const fullHistory = updateLocalHistory(usageRes.usage || []);
+        const tierInfo = TIER_LIMITS[profile.tier] || { pollen: 1, emoji: '❓' };
         const tierLimit = tierInfo.pollen;
-        // Calculer le reset
+        // 3. Calculate Reset & Usage from History
         const resetInfo = calculateResetInfo(profile.nextResetAt);
-        // Calculer l'usage de la période actuelle
-        const { tierUsed } = calculateCurrentPeriodUsage(usage, resetInfo);
+        const { tierUsed } = calculateCurrentPeriodUsage(fullHistory, resetInfo);
+        // 4. Calculate Balances
         const tierRemaining = Math.max(0, tierLimit - tierUsed);
         // Fix rounding errors
         const cleanTierRemaining = Math.max(0, parseFloat(tierRemaining.toFixed(4)));
         // Le wallet c'est le reste (balance totale - ce qu'il reste du tier gratuit non consommé)
+        // Formula: Pollinations Balance = Wallet + TierRemaining.
         const walletBalance = Math.max(0, balance - cleanTierRemaining);
         const cleanWalletBalance = Math.max(0, parseFloat(walletBalance.toFixed(4)));
+        // needsAlert: check BOTH tier threshold AND wallet threshold
+        const tierAlertPercent = tierLimit > 0 ? (cleanTierRemaining / tierLimit * 100) : 0;
+        const tierNeedsAlert = tierLimit > 0 && tierAlertPercent <= config.thresholds.tier;
+        const walletNeedsAlert = cleanWalletBalance > 0 && cleanWalletBalance < (config.thresholds.wallet || 0.5);
         cachedQuota = {
             tierRemaining: cleanTierRemaining,
             tierUsed,
@@ -74,7 +132,7 @@ export async function getQuotaStatus(forceRefresh = false) {
             timeUntilReset: resetInfo.timeUntilReset,
             canUseEnterprise: cleanTierRemaining > 0.05 || cleanWalletBalance > 0.05,
             isUsingWallet: cleanTierRemaining <= 0.05 && cleanWalletBalance > 0.05,
-            needsAlert: tierLimit > 0 ? (cleanTierRemaining / tierLimit * 100) <= config.thresholds.tier : false,
+            needsAlert: tierNeedsAlert || walletNeedsAlert,
             tier: profile.tier,
             tierEmoji: tierInfo.emoji
         };
@@ -84,30 +142,29 @@ export async function getQuotaStatus(forceRefresh = false) {
     catch (e) {
         logQuota(`ERROR fetching quota: ${e.message}`);
         let errorType = 'unknown';
-        if (e.message && e.message.includes('403')) {
+        if (e.message && e.message.includes('403'))
             errorType = 'auth_limited';
-        }
-        else if (e.message && e.message.includes('Network Error')) {
+        else if (e.message && e.message.includes('Network Error'))
             errorType = 'network';
-        }
-        // Retourner le cache ou un état par défaut safe
-        return cachedQuota || {
-            tierRemaining: 0,
-            tierUsed: 0,
-            tierLimit: 1,
-            walletBalance: 0,
-            nextResetAt: new Date(),
-            timeUntilReset: 0,
-            canUseEnterprise: false,
-            isUsingWallet: false,
-            needsAlert: true,
-            tier: 'error',
-            tierEmoji: '⚠️',
-            errorType
-        };
+        return cachedQuota || { ...createDefaultQuota('error', 1), errorType };
     }
 }
-// === HELPERS (Native HTTPS) ===
+function createDefaultQuota(tierName, limit) {
+    return {
+        tierRemaining: 0,
+        tierUsed: 0,
+        tierLimit: limit,
+        walletBalance: 0,
+        nextResetAt: new Date(),
+        timeUntilReset: 0,
+        canUseEnterprise: false,
+        isUsingWallet: false,
+        needsAlert: false,
+        tier: tierName,
+        tierEmoji: TIER_LIMITS[tierName]?.emoji || '❌'
+    };
+}
+// === HELPERS ===
 function fetchAPI(endpoint, apiKey) {
     return new Promise((resolve, reject) => {
         const options = {
@@ -146,28 +203,23 @@ function fetchAPI(endpoint, apiKey) {
 function calculateResetInfo(nextResetAt) {
     const nextResetFromAPI = new Date(nextResetAt);
     const now = new Date();
-    // Extraire l'heure de reset depuis l'API (varie par utilisateur!)
     const resetHour = nextResetFromAPI.getUTCHours();
     const resetMinute = nextResetFromAPI.getUTCMinutes();
     const resetSecond = nextResetFromAPI.getUTCSeconds();
-    // Calculer le reset d'aujourd'hui à cette heure
     const todayResetUTC = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), resetHour, resetMinute, resetSecond));
     let lastReset;
     let nextReset;
     if (now >= todayResetUTC) {
-        // Le reset d'aujourd'hui est passé
         lastReset = todayResetUTC;
-        nextReset = new Date(todayResetUTC.getTime() + 24 * 60 * 60 * 1000);
+        nextReset = new Date(todayResetUTC.getTime() + ONE_DAY_MS);
     }
     else {
-        // Le reset d'aujourd'hui n'est pas encore passé
-        lastReset = new Date(todayResetUTC.getTime() - 24 * 60 * 60 * 1000);
+        lastReset = new Date(todayResetUTC.getTime() - ONE_DAY_MS);
         nextReset = todayResetUTC;
     }
     const timeUntilReset = nextReset.getTime() - now.getTime();
     const timeSinceReset = now.getTime() - lastReset.getTime();
-    const cycleDuration = 24 * 60 * 60 * 1000;
-    const progressPercent = (timeSinceReset / cycleDuration) * 100;
+    const progressPercent = (timeSinceReset / ONE_DAY_MS) * 100;
     return {
         nextReset,
         lastReset,
@@ -182,15 +234,10 @@ function calculateResetInfo(nextResetAt) {
 function calculateCurrentPeriodUsage(usage, resetInfo) {
     let tierUsed = 0;
     let packUsed = 0;
-    // Parser le timestamp de l'API avec Z pour UTC
-    function parseUsageTimestamp(timestamp) {
-        // Format: "2026-01-23 01:11:21"
-        const isoString = timestamp.replace(' ', 'T') + 'Z';
-        return new Date(isoString);
-    }
-    // FILTRER: Ne garder que les entrées APRÈS le dernier reset
     const entriesAfterReset = usage.filter(entry => {
-        const entryTime = parseUsageTimestamp(entry.timestamp);
+        // Safe Parse
+        const timestamp = entry.timestamp.replace(' ', 'T') + 'Z';
+        const entryTime = new Date(timestamp);
         return entryTime >= resetInfo.lastReset;
     });
     for (const entry of entriesAfterReset) {
@@ -203,7 +250,6 @@ function calculateCurrentPeriodUsage(usage, resetInfo) {
     }
     return { tierUsed, packUsed };
 }
-// === EXPORT POUR LES ALERTES ===
 export function formatQuotaForToast(quota) {
     if (quota.errorType === 'auth_limited') {
         return `🔑 CLE LIMITÉE (Génération Seule) | 💎 Wallet: N/A | ⏰ Reset: N/A`;
@@ -211,7 +257,6 @@ export function formatQuotaForToast(quota) {
     const tierPercent = quota.tierLimit > 0
         ? Math.round((quota.tierRemaining / quota.tierLimit) * 100)
         : 0;
-    // Format compact: 1h23m
     const ms = quota.timeUntilReset;
     const hours = Math.floor(ms / (1000 * 60 * 60));
     const minutes = Math.floor((ms % (1000 * 60 * 60)) / (1000 * 60));

package/dist/server/toast.d.ts

@@ -4,3 +4,6 @@ export declare function emitStatusToast(type: 'info' | 'warning' | 'error' | 'su
 export declare function createToastHooks(client: any): {
     'session.idle': ({ event }: any) => Promise<void>;
 };
+export declare function createToolHooks(client: any): {
+    'tool.execute.after': (input: any, output: any) => Promise<void>;
+};