opencode-pollinations-plugin 6.1.0-beta.12 → 6.1.0-beta.22

package/dist/server/proxy.js

@@ -3,20 +3,13 @@ import * as path from 'path';
 import { loadConfig, saveConfig } from './config.js';
 import { handleCommand } from './commands.js';
 import { emitStatusToast, emitLogToast } from './toast.js';
+import { buildConnectResponse } from './connect-response.js';
+import { log } from './logger.js';
+import { getConfigDir } from './config.js';
 // --- PERSISTENCE: SIGNATURE MAP (Multi-Round Support) ---
-const SIG_FILE = path.join(process.env.HOME || '/tmp', '.config/opencode/pollinations-signature.json');
+const SIG_FILE = path.join(getConfigDir(), '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'));
@@ -265,25 +258,57 @@ 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',
+        // 0. TEST 4: Virtual Model Handler for Commands
+        if (body.model === 'pollinations/pollimock-handler' || body.model === 'pollimock-handler') {
+            const mockContent = "🚀 **[TEST 4] Modèle Virtuel de Commande !**\n\nCe texte n'a jamais quitté ton ordinateur. La commande `/pollimock` a demandé à OpenCode de se brancher temporairement sur le modèle virtuel `pollimock-handler`.\nLe proxy a intercepté cet appel et répondu instantanément.\n\n✅ L'historique affiche bien le message du Chat, **mais la requête LLM est totalement court-circuitée**.\nC'est la méthode ultime pour créer des vues de configuration via commandes (`/pollinations-config` par ex) sans polluer le crédit ou les LLM tiers !";
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive'
+            });
+            const chunk = JSON.stringify({
+                id: 'mock-' + Date.now(),
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: body.model,
+                choices: [{ index: 0, delta: { role: 'assistant', content: mockContent }, finish_reason: null }]
+            });
+            res.write(`data: ${chunk}\n\n`);
+            const chunkEnd = JSON.stringify({
+                id: 'mock-' + Date.now(),
+                object: 'chat.completion.chunk',
                 created: Math.floor(Date.now() / 1000),
-                model: 'connect-pollinations',
+                model: body.model,
+                choices: [{ index: 0, delta: {}, finish_reason: 'stop' }]
+            });
+            res.write(`data: ${chunkEnd}\n\n`);
+            res.write('data: [DONE]\n\n');
+            res.end();
+            return;
+        }
+        // 0. SPECIAL: pollinations/connect (Guide & Status)
+        const CONNECT_MODEL_IDS = ['pollinations/connect', 'free/pollinations/connect', 'enter/pollinations/connect', 'connect-pollinations'];
+        if (CONNECT_MODEL_IDS.includes(body.model)) {
+            const guideContent = await buildConnectResponse(config);
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive'
+            });
+            const chunk = JSON.stringify({
+                id: 'connect-' + Date.now(),
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: 'pollinations/connect',
                 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));
+                        delta: { role: 'assistant', content: guideContent },
+                        finish_reason: 'stop' // Instant finish
+                    }]
+            });
+            res.write(`data: ${chunk}\n\n`);
+            res.write(`data: [DONE]\n\n`);
+            res.end();
             return;
         }
         // 1. STRICT ROUTING & SAFETY NET LOGIC (V5)

package/dist/server/quota.d.ts

@@ -1,11 +1,4 @@
-export interface DetailedUsageEntry {
-    timestamp: string;
-    type: string;
-    model: string;
-    meter_source: 'tier' | 'pack';
-    cost_usd: number;
-    requests?: number;
-}
+import { DetailedUsageEntry } from './pollinations-api.js';
 export interface QuotaStatus {
     tierRemaining: number;
     tierUsed: number;
@@ -20,5 +13,6 @@ export interface QuotaStatus {
     tierEmoji: string;
     errorType?: 'auth_limited' | 'network' | 'unknown';
 }
+export declare function fetchUsageForPeriod(apiKey: string, lastReset: Date): Promise<DetailedUsageEntry[]>;
 export declare function getQuotaStatus(forceRefresh?: boolean): Promise<QuotaStatus>;
 export declare function formatQuotaForToast(quota: QuotaStatus): string;

package/dist/server/quota.js

@@ -1,7 +1,4 @@
-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 & CONSTANTS ===
 const CACHE_TTL = 30000; // 30 secondes
@@ -18,71 +15,45 @@ const TIER_LIMITS = {
     nectar: { pollen: 20, emoji: '🍯' },
 };
 // === LOGGING ===
+import { logApi } from './logger.js';
 function logQuota(msg) {
-    try {
-        fs.appendFileSync('/tmp/pollinations_quota_debug.log', `[${new Date().toISOString()}] ${msg}\n`);
-    }
-    catch (e) { }
+    logApi(`[QUOTA] ${msg}`);
 }
-// === HISTORY MANAGER (JSON) ===
-function getHistoryFilePath() {
-    const homedir = process.env.HOME || '/tmp';
-    const historyDir = path.join(homedir, '.pollinations');
-    if (!fs.existsSync(historyDir)) {
+// === SMART FETCH API ===
+export async function fetchUsageForPeriod(apiKey, lastReset) {
+    let allUsage = [];
+    let offset = 0;
+    const limit = 100; // Bulk fetch 
+    while (true) {
+        let usageRes;
         try {
-            fs.mkdirSync(historyDir, { recursive: true });
+            usageRes = await fetchAPI(`/account/usage?limit=${limit}&offset=${offset}`, apiKey);
         }
-        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(`SmartFetch failed at offset ${offset}: ${e}`);
+            break;
         }
-    }
-    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++;
+        if (!usageRes.usage || usageRes.usage.length === 0) {
+            break; // No more records
         }
+        let reachedCutoff = false;
+        for (const entry of usageRes.usage) {
+            const timestampStr = entry.timestamp.includes('Z') ? entry.timestamp : entry.timestamp.replace(' ', 'T') + 'Z';
+            const entryTime = new Date(timestampStr);
+            if (entryTime < lastReset) {
+                reachedCutoff = true;
+                break; // Entry is from previous period, stop.
+            }
+            allUsage.push(entry);
+        }
+        // If we found an entry older than lastReset, or if the page was not full, we reached the end.
+        if (reachedCutoff || usageRes.usage.length < limit) {
+            break;
+        }
+        offset += limit;
     }
-    // 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;
+    logQuota(`SmartFetch: Retrieved ${allUsage.length} transactions for current period.`);
+    return allUsage;
 }
 // === MAIN QUOTA FUNCTION ===
 export async function getQuotaStatus(forceRefresh = false) {
@@ -100,17 +71,17 @@ export async function getQuotaStatus(forceRefresh = false) {
         // SEQUENTIAL FETCH (Avoid Rate Limits)
         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;
-        // 2. Update Local History (The Source of Truth)
-        const fullHistory = updateLocalHistory(usageRes.usage || []);
+        // 2. Convertir Timezone : Obtenir instant exact du Reset
+        const resetInfo = calculateResetInfo(profile.nextResetAt);
+        logQuota(`Fetch Success. Tier: ${profile.tier}, Balance: ${balance}, Next Reset: ${profile.nextResetAt}`);
+        // 3. Smart Fetch : Récupérer uniquement les dépenses du jour (depuis lastReset)
+        const periodUsage = await fetchUsageForPeriod(config.apiKey, resetInfo.lastReset);
         const tierInfo = TIER_LIMITS[profile.tier] || { pollen: 1, emoji: '❓' };
         const tierLimit = tierInfo.pollen;
-        // 3. Calculate Reset & Usage from History
-        const resetInfo = calculateResetInfo(profile.nextResetAt);
-        const { tierUsed } = calculateCurrentPeriodUsage(fullHistory, resetInfo);
+        // 4. Calcul Strict FreeTier / Wallet
+        const { tierUsed } = calculateCurrentPeriodUsage(periodUsage, resetInfo);
         // 4. Calculate Balances
         const tierRemaining = Math.max(0, tierLimit - tierUsed);
         // Fix rounding errors
@@ -201,33 +172,20 @@ function fetchAPI(endpoint, apiKey) {
     });
 }
 function calculateResetInfo(nextResetAt) {
-    const nextResetFromAPI = new Date(nextResetAt);
+    const nextReset = new Date(nextResetAt);
+    const lastReset = new Date(nextReset.getTime() - ONE_DAY_MS);
     const now = new Date();
-    const resetHour = nextResetFromAPI.getUTCHours();
-    const resetMinute = nextResetFromAPI.getUTCMinutes();
-    const resetSecond = nextResetFromAPI.getUTCSeconds();
-    const todayResetUTC = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), resetHour, resetMinute, resetSecond));
-    let lastReset;
-    let nextReset;
-    if (now >= todayResetUTC) {
-        lastReset = todayResetUTC;
-        nextReset = new Date(todayResetUTC.getTime() + ONE_DAY_MS);
-    }
-    else {
-        lastReset = new Date(todayResetUTC.getTime() - ONE_DAY_MS);
-        nextReset = todayResetUTC;
-    }
-    const timeUntilReset = nextReset.getTime() - now.getTime();
-    const timeSinceReset = now.getTime() - lastReset.getTime();
-    const progressPercent = (timeSinceReset / ONE_DAY_MS) * 100;
+    const timeUntilReset = Math.max(0, nextReset.getTime() - now.getTime());
+    const timeSinceReset = Math.max(0, now.getTime() - lastReset.getTime());
+    const progressPercent = Math.min(100, (timeSinceReset / ONE_DAY_MS) * 100);
     return {
         nextReset,
         lastReset,
         timeUntilReset,
         timeSinceReset,
-        resetHour,
-        resetMinute,
-        resetSecond,
+        resetHour: nextReset.getUTCHours(),
+        resetMinute: nextReset.getUTCMinutes(),
+        resetSecond: nextReset.getUTCSeconds(),
         progressPercent
     };
 }

package/dist/server/scripts/pollinations_pricing.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env npx tsx
+/**
+ * pollinations_pricing.ts — CLI Pricing Table for enter.pollinations.ai
+ * * Usage: npx tsx pollinations_pricing.ts [--api-key YOUR_KEY] [--debug] [--mode normal|dynamic]
+ * * - Mode 'normal' (défaut) : Affiche le miroir exact du dashboard marketing.
+ * - Mode 'dynamic' : Calcule le vrai coût token par token (Cost Guard Estimator).
+ */
+export {};

package/dist/server/scripts/pollinations_pricing.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env npx tsx
+/**
+ * pollinations_pricing.ts — CLI Pricing Table for enter.pollinations.ai
+ * * Usage: npx tsx pollinations_pricing.ts [--api-key YOUR_KEY] [--debug] [--mode normal|dynamic]
+ * * - Mode 'normal' (défaut) : Affiche le miroir exact du dashboard marketing.
+ * - Mode 'dynamic' : Calcule le vrai coût token par token (Cost Guard Estimator).
+ */
+const args = process.argv.slice(2);
+const API_KEY = args.includes("--api-key") ? args[args.indexOf("--api-key") + 1] : process.env.POLLINATIONS_API_KEY ?? "";
+const DEBUG = args.includes("--debug");
+const modeIndex = args.indexOf("--mode");
+const MODE = modeIndex !== -1 ? args[modeIndex + 1] : "normal";
+const H = API_KEY ? { Authorization: `Bearer ${API_KEY}` } : {};
+async function get(url) {
+    const r = await fetch(url, { headers: H });
+    if (!r.ok)
+        throw new Error(`HTTP ${r.status} on ${url}`);
+    return r.json();
+}
+// ─── COST GUARD ESTIMATOR (Pour le mode dynamic) ─────────────────────────────
+const BENCH = {
+    TEXT_IN_TOK: 300,
+    TEXT_OUT_TOK: 800,
+    IMG_TOKENS_PER_STD: 1667,
+    VIDEO_DEFAULT_SEC: 6,
+    STT_CLIP_SEC: 30,
+    TTS_CHARS: 200,
+    MUSIC_SEC: 50,
+    VIDEO_DURATION: { veo: 6, "seedance-pro": 5, seedance: 5, "ltx-2": 6, wan: 5, "grok-video": 5 },
+    VIDEO_DEFAULT_TOKENS: 50_000,
+};
+let globalModelStats = [];
+function n(v) {
+    const x = Number(v);
+    return v === undefined || v === null || isNaN(x) || x === 0 ? null : x;
+}
+function perM(v) {
+    const x = n(v);
+    if (!x)
+        return "—";
+    const m = x * 1_000_000;
+    return m >= 100 ? `${m.toFixed(1)}/M` : m >= 10 ? `${m.toFixed(2)}/M` : m >= 1 ? `${m.toFixed(3)}/M` : `${m.toFixed(4)}/M`;
+}
+function flat(v, unit) {
+    const x = n(v);
+    if (!x)
+        return "—";
+    return x >= 1 ? `${x.toFixed(3)}/${unit}` : x >= 0.01 ? `${x.toFixed(4)}/${unit}` : `${x.toFixed(5)}/${unit}`;
+}
+function per1pollen(cost) {
+    if (!cost || cost <= 0)
+        return "—";
+    const x = 1 / cost;
+    if (x >= 1_000_000)
+        return `${(x / 1_000_000).toFixed(1)}M`;
+    if (x >= 100_000)
+        return `${Math.round(x / 1000)}K`;
+    if (x >= 10_000)
+        return `${(x / 1000).toFixed(1)}K`.replace(/\.0K$/, "K");
+    if (x >= 1_000)
+        return `${Math.round(x / 100) * 100}`.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+    if (x >= 100)
+        return `${Math.round(x)}`;
+    if (x >= 10)
+        return `${Math.round(x * 10) / 10}`;
+    return `${x.toFixed(1)}`;
+}
+function getCost(m, type) {
+    // 1. Priorité aux Stats Tinybird si on est en mode normal
+    if (MODE === "normal") {
+        // Tente de trouver la variable native à la racine (si l'API l'expose)
+        const rootCost = n(m.realAvgCost) ?? n(m.baseCost) ?? n(m.pollenCost) ?? n(m.averageCost);
+        if (rootCost)
+            return rootCost;
+        // Fallback dynamique sur les stats Tinybird
+        const stat = globalModelStats.find(s => s.model === m.name);
+        if (stat && stat.avg_cost_usd > 0)
+            return stat.avg_cost_usd;
+    }
+    // 2. Calcul mathématique (Mode Dynamic ou si Modèle inconnu)
+    const pr = m.pricing ?? {};
+    if (type === "text") {
+        return (n(pr.promptTextTokens) ?? 0) * BENCH.TEXT_IN_TOK + (n(pr.completionTextTokens) ?? 0) * BENCH.TEXT_OUT_TOK || null;
+    }
+    if (type === "image") {
+        const outPrice = n(pr.completionImageTokens);
+        if (!outPrice)
+            return null;
+        if (pr.promptTextTokens) {
+            return (n(pr.promptTextTokens) ?? 0) * 100 + (n(pr.promptImageTokens) ?? 0) * 100 + (outPrice * BENCH.IMG_TOKENS_PER_STD);
+        }
+        return outPrice;
+    }
+    if (type === "video") {
+        if (pr.completionVideoSeconds) {
+            return ((n(pr.completionVideoSeconds) ?? 0) + (n(pr.completionAudioSeconds) ?? 0)) * (BENCH.VIDEO_DURATION[m.name] ?? BENCH.VIDEO_DEFAULT_SEC);
+        }
+        return n(pr.completionVideoTokens) ? (n(pr.completionVideoTokens) ?? 0) * BENCH.VIDEO_DEFAULT_TOKENS : null;
+    }
+    if (type === "audio") {
+        if (n(pr.promptAudioSeconds))
+            return (n(pr.promptAudioSeconds) ?? 0) * BENCH.STT_CLIP_SEC;
+        if (n(pr.completionAudioSeconds))
+            return (n(pr.completionAudioSeconds) ?? 0) * BENCH.MUSIC_SEC;
+        if (n(pr.completionAudioTokens))
+            return (n(pr.completionAudioTokens) ?? 0) * BENCH.TTS_CHARS;
+    }
+    return null;
+}
+// ─── RENDU VISUEL ────────────────────────────────────────────────────────────
+function parseNameDesc(m) {
+    const fullDesc = m.description || m.name;
+    const parts = fullDesc.split(" - ");
+    if (parts.length > 1) {
+        return { nom: parts[0].trim(), desc: parts.slice(1).join(" - ").trim() };
+    }
+    return { nom: fullDesc, desc: "" };
+}
+function flags(m, overrides = []) {
+    const f = [];
+    if (m.paid_only)
+        f.push("💎");
+    const allFlags = [...(m.input_modalities || []), ...(m.output_modalities || []), ...overrides, m.name];
+    const str = allFlags.join(" ").toLowerCase();
+    if (str.includes("image") || str.includes("👁️"))
+        f.push("👁️");
+    if (m.reasoning || str.includes("reasoning"))
+        f.push("🧠");
+    if (str.includes("audio") && !overrides.includes("🔊") || str.includes("whisper") || str.includes("scribe") || str.includes("🎙️"))
+        f.push("🎙️");
+    if (str.includes("search") || str.includes("sonar") || str.includes("gemini"))
+        f.push("🔍");
+    if (m.output_modalities?.includes("audio") || overrides.includes("🔊") || str.includes("tts") || str.includes("music"))
+        f.push("🔊");
+    if (str.includes("coder") || str.includes("code") || str.includes("gemini"))
+        f.push("💻");
+    if ((m.context_window ?? 0) >= 100_000)
+        f.push(`📏${((m.context_window ?? 0) / 1000).toFixed(0)}k`);
+    return f.filter((v, i, a) => a.indexOf(v) === i).join(" ");
+}
+function renderTable(title, models, type, extraFlags = []) {
+    if (models.length === 0)
+        return "";
+    // Tri par coût (du moins cher au plus cher), puis ordre alphabétique
+    const sorted = [...models].sort((a, b) => {
+        const costA = getCost(a, type) ?? 0;
+        const costB = getCost(b, type) ?? 0;
+        const diff = costA - costB;
+        if (diff !== 0)
+            return diff;
+        return a.name.localeCompare(b.name);
+    });
+    const lines = [
+        `\n## ${title}\n`,
+        `| Nom | ID | Capabilities | 1 pollen ≈ | Pricing |`,
+        `|---|---|---|---|---|`
+    ];
+    for (const m of sorted) {
+        const pr = m.pricing ?? {};
+        const parts = [];
+        // Génération de la colonne Pricing en fonction du type
+        if (type === "text") {
+            if (n(pr.promptTextTokens))
+                parts.push(`💬 ${perM(pr.promptTextTokens)}`);
+            if (n(pr.promptCachedTokens))
+                parts.push(`💾 ${perM(pr.promptCachedTokens)}`);
+            if (n(pr.completionTextTokens))
+                parts.push(`💬 ${perM(pr.completionTextTokens)}`);
+        }
+        else if (type === "image") {
+            if (pr.promptTextTokens)
+                parts.push(`💬 ${perM(pr.promptTextTokens)}`);
+            if (pr.completionImageTokens)
+                parts.push(`🖼️ ${pr.promptTextTokens ? perM(pr.completionImageTokens) : flat(pr.completionImageTokens, "img")}`);
+        }
+        else if (type === "video") {
+            if (pr.completionVideoSeconds)
+                parts.push(`🎬 ${flat(pr.completionVideoSeconds, "sec")}`);
+            if (pr.completionVideoTokens)
+                parts.push(`🎬 ${perM(pr.completionVideoTokens)}`);
+        }
+        else if (type === "audio") {
+            if (pr.promptAudioSeconds)
+                parts.push(`🎬 ${flat(pr.promptAudioSeconds, "sec")}`);
+            if (pr.completionAudioTokens)
+                parts.push(`🔊 ${((n(pr.completionAudioTokens) ?? 0) * 1000).toFixed(2)}/1K chars`);
+            if (pr.completionAudioSeconds)
+                parts.push(`🎬 ${flat(pr.completionAudioSeconds, "sec")}`);
+        }
+        const { nom } = parseNameDesc(m);
+        lines.push(`| ${nom} | \`${m.name}\` | ${flags(m, extraFlags)} | ${per1pollen(getCost(m, type))} | ${parts.join(" · ") || "—"} |`);
+    }
+    return lines.join("\n");
+}
+// ─── DEBUG ULTIME ────────────────────────────────────────────────────────────
+function debugDump(label, models) {
+    if (!DEBUG)
+        return;
+    console.error(`\n[debug] ═══ ROOT OBJECT DUMP: ${label} (${models.length} models) ═══`);
+    for (const m of models) {
+        const clone = { ...m };
+        delete clone.description; // Pour garder le terminal lisible
+        console.error(JSON.stringify(clone, null, 2));
+    }
+}
+// ─── EXECUTION MAIN ──────────────────────────────────────────────────────────
+const BASE = "https://gen.pollinations.ai";
+const STATS = "https://enter.pollinations.ai/api/model-stats";
+const [text, imgRaw, audRaw, statsRaw] = await Promise.all([
+    get(`${BASE}/text/models`),
+    get(`${BASE}/image/models`),
+    get(`${BASE}/audio/models`),
+    get(STATS).catch(() => ({ data: [] }))
+]);
+globalModelStats = statsRaw.data;
+// Séparation des modèles images et vidéos qui sont mixés sur le même endpoint
+const isVid = (m) => (m.pricing?.completionVideoSeconds || m.pricing?.completionVideoTokens) !== undefined;
+const img = imgRaw.filter(m => !isVid(m));
+const vid = imgRaw.filter(m => isVid(m));
+// Séparation Audio
+const isSTT = (m) => !!m.pricing?.promptAudioSeconds;
+const isMusic = (m) => m.name.includes("music");
+const stt = audRaw.filter(m => isSTT(m));
+const tts = audRaw.filter(m => !isSTT(m) && !isMusic(m));
+const music = audRaw.filter(m => isMusic(m));
+debugDump("IMAGE API", img);
+debugDump("VIDEO API", vid);
+debugDump("AUDIO API", audRaw);
+debugDump("TEXT API", text);
+console.log(`# 🌸 Pollinations — Live Model Pricing (Mode: ${MODE.toUpperCase()})`);
+console.log(`> **${new Date().toISOString()}** · ${img.length} image · ${vid.length} video · ${audRaw.length} audio · ${text.length} text`);
+console.log(renderTable("🖼️ Image", img, "image"));
+console.log(renderTable("🎬 Video", vid, "video", ["👁️"]));
+console.log(renderTable("🎙️ Speech-to-Text", stt, "audio", ["🎙️"]));
+console.log(renderTable("🔊 Text-to-Speech", tts, "audio", ["🔊"]));
+console.log(renderTable("🎵 Music", music, "audio", ["🔊"]));
+console.log(renderTable("📝 Text", text, "text"));
+console.log(`\n> **Capabilities** : 👁️ vision · 🧠 reasoning · 🎙️ audio in · 🔍 search · 🔊 audio out · 💻 code exec`);
+console.log(`> **Token Types** : 💬 text · 🖼️ image · 💾 cached · 🎬 video · 🔊 audio`);
+console.log(`> **Pricing Metrics** : /img = flat rate per image · /M = per million tokens · /sec = per second of video · /1K chars = per 1000 characters`);
+console.log(`> **Other** : 💎 PAID ONLY (Wallet direct) · 📏 Contexte API max`);
+console.log(`\n### 💡 How Pollen is Spent
+1. Daily tier grants are used first
+2. Purchased pollen is used after daily is depleted
+⚠️ **Exception**: 💎 Paid Only models require purchased pollen only`);
+export {};

package/dist/server/scripts/test_cost_endpoints.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/scripts/test_cost_endpoints.js

@@ -0,0 +1,61 @@
+const API_KEY = process.env.POLLINATIONS_API_KEY || 'sk_eZbhgG1oJaaqSZKMvmy8nfVH9NNAGp0H';
+async function logBalance(label) {
+    try {
+        const res = await fetch('https://gen.pollinations.ai/account/balance', {
+            headers: { 'Authorization': `Bearer ${API_KEY}` }
+        });
+        const bal = await res.json();
+        console.log(`\n[${label}] /account/balance :`);
+        console.log(JSON.stringify(bal, null, 2));
+        const resUsage = await fetch('https://gen.pollinations.ai/account/usage/daily', {
+            headers: { 'Authorization': `Bearer ${API_KEY}` }
+        });
+        const usg = await resUsage.json();
+        // Sum today stats
+        let costTier = 0;
+        let costPack = 0;
+        let req = 0;
+        if (usg.usage && usg.usage.length > 0) {
+            const todayDate = usg.usage[0].date;
+            for (const x of usg.usage) {
+                if (x.date === todayDate) {
+                    req += x.requests;
+                    if (x.meter_source === 'tier')
+                        costTier += x.cost_usd;
+                    else
+                        costPack += x.cost_usd;
+                }
+            }
+        }
+        console.log(`[${label}] /account/usage/daily (Today sum) : Requests = ${req}, TierCost = ${costTier}, PackCost = ${costPack}`);
+        return { bal, usage: { costTier, costPack, req } };
+    }
+    catch (e) {
+        console.error("Error fetching balance/usage:", e.message);
+        return null;
+    }
+}
+async function run() {
+    console.log("=== COST ENDPOINTS PROBE ===");
+    // 1. Avant
+    const stateBefore = await logBalance("BEFORE GENERATION");
+    // 2. Générer Fake Image (Flux : censé être free tier ou cheap)
+    console.log("\n🎬 Génération d'une image (modèle 'flux')...");
+    const url = 'https://gen.pollinations.ai/image/a_beautiful_red_square_cost_test?model=flux&width=512&height=512&nologo=true';
+    const start = Date.now();
+    const res = await fetch(url, { headers: { 'Authorization': `Bearer ${API_KEY}` } });
+    const buffer = await res.arrayBuffer();
+    console.log(`✅ Image reçue en ${Date.now() - start}ms, taille: ${buffer.byteLength}B`);
+    console.log(`Headers Cost:`, {
+        'x-usage-cost-usd': res.headers.get('x-usage-cost-usd'),
+        'x-usage-completion-image-tokens': res.headers.get('x-usage-completion-image-tokens')
+    });
+    // 3. Immediatement Apres
+    await logBalance("IMMEDIATELY AFTER");
+    // 4. Attente 5 secondes
+    console.log("\n⏳ Attente 5 secondes pour propagation /usage...");
+    await new Promise(r => setTimeout(r, 5000));
+    await logBalance("5 SECONDS AFTER");
+}
+run();
+export {};

package/dist/server/scripts/test_dynamic_pricing.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/scripts/test_dynamic_pricing.js

@@ -0,0 +1,39 @@
+import * as https from 'https';
+function fetchJson(url) {
+    return new Promise((resolve, reject) => {
+        https.get(url, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => resolve(JSON.parse(data)));
+        }).on('error', reject);
+    });
+}
+async function auditDynamicPricing() {
+    console.log("=== AUDIT PRICING DYNAMIQUE (TINYBIRD) ===");
+    try {
+        console.log("Fetching /api/model-stats...");
+        const statsProxy = await fetchJson('https://enter.pollinations.ai/api/model-stats');
+        const stats = statsProxy.data || [];
+        console.log(`\nReçu ${stats.length} statistiques de prix moyens (average cost) depuis Tinybird:`);
+        // On affiche les 10 premiers pour l'exemple
+        console.log(stats.slice(0, 10).map((s) => `- ${s.model}: ${parseFloat(s.avg_cost_usd).toFixed(6)}$/req (${s.request_count} reqs)`).join('\n'));
+        console.log("\nFetching /image/models...");
+        const imageModels = await fetchJson('https://gen.pollinations.ai/image/models');
+        console.log("\nCroisement Models API vs Tinybird Stats:");
+        for (const m of imageModels.slice(0, 5)) {
+            const stat = stats.find((s) => s.model === m.name);
+            console.log(`\nModèle: ${m.name}`);
+            console.log(`- API Pricing Base:`, m.pricing);
+            if (stat) {
+                console.log(`- Tinybird Real Average Cost: ${stat.avg_cost_usd}$ (Basé sur le vrai usage!)`);
+            }
+            else {
+                console.log(`- Tinybird Stats: Inconnu / Pas d'usage récent`);
+            }
+        }
+    }
+    catch (e) {
+        console.error("Erreur lors de l'audit:", e.message);
+    }
+}
+auditDynamicPricing();