opencode-pollinations-plugin 6.1.0-beta.9 → 6.2.1

package/dist/server/quota.d.ts

@@ -1,3 +1,4 @@
+import { DetailedUsageEntry } from './pollinations-api.js';
 export interface QuotaStatus {
     tierRemaining: number;
     tierUsed: number;
@@ -12,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,42 +1,65 @@
-import * as fs from 'fs';
 import * as https from 'https'; // Use Native HTTPS
 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: '🌸' },
     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`);
+    logApi(`[QUOTA] ${msg}`);
+}
+// === SMART FETCH API ===
+export async function fetchUsageForPeriod(apiKey, lastReset) {
+    let allUsage = [];
+    let offset = 0;
+    const limit = 100; // Bulk fetch 
+    while (true) {
+        let usageRes;
+        try {
+            usageRes = await fetchAPI(`/account/usage?limit=${limit}&offset=${offset}`, apiKey);
+        }
+        catch (e) {
+            logQuota(`SmartFetch failed at offset ${offset}: ${e}`);
+            break;
+        }
+        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;
     }
-    catch (e) { }
+    logQuota(`SmartFetch: Retrieved ${allUsage.length} transactions for current period.`);
+    return allUsage;
 }
-// === FONCTIONS PRINCIPALES ===
+// === 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 +67,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)
-        const tierLimit = tierInfo.pollen;
-        // Calculer le reset
+        // 2. Convertir Timezone : Obtenir instant exact du Reset
         const resetInfo = calculateResetInfo(profile.nextResetAt);
-        // Calculer l'usage de la période actuelle
-        const { tierUsed } = calculateCurrentPeriodUsage(usage, resetInfo);
+        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;
+        // 4. Calcul Strict FreeTier / Wallet
+        const { tierUsed } = calculateCurrentPeriodUsage(periodUsage, 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 +103,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 +113,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 = {
@@ -144,53 +172,30 @@ 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();
-    // 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);
-    }
-    else {
-        // Le reset d'aujourd'hui n'est pas encore passé
-        lastReset = new Date(todayResetUTC.getTime() - 24 * 60 * 60 * 1000);
-        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 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
     };
 }
 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 +208,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 +215,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/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();

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

@@ -0,0 +1,11 @@
+/**
+ * TEST FREETIER AUDIT — Quick & Dirty
+ * Objectif: Tester les modèles freetier Enter pour vérifier:
+ * - Latence de réponse
+ * - Headers de coût (x-usage-*)
+ * - Real cost via /account/balance diff
+ * - Erreurs et paramètres
+ *
+ * Usage: npx tsx src/server/scripts/test_freetier_audit.ts
+ */
+export {};