opencode-pollinations-plugin 5.1.3

package/dist/server/quota.js

@@ -0,0 +1,210 @@
+import * as fs from 'fs';
+import * as https from 'https'; // Use Native HTTPS
+import { loadConfig } from './config.js';
+// === CACHE ===
+const CACHE_TTL = 30000; // 30 secondes
+let cachedQuota = null;
+let lastQuotaFetch = 0;
+// === TIER LIMITS ===
+const TIER_LIMITS = {
+    spore: { pollen: 1, emoji: '🦠' },
+    seed: { pollen: 3, emoji: '🌱' },
+    flower: { pollen: 10, emoji: '🌸' },
+    nectar: { pollen: 20, emoji: '🍯' },
+};
+// === LOGGING ===
+function logQuota(msg) {
+    try {
+        fs.appendFileSync('/tmp/pollinations_quota_debug.log', `[${new Date().toISOString()}] ${msg}\n`);
+    }
+    catch (e) { }
+}
+// === FONCTIONS PRINCIPALES ===
+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: '❌'
+        };
+    }
+    const now = Date.now();
+    if (!forceRefresh && cachedQuota && (now - lastQuotaFetch) < CACHE_TTL) {
+        return cachedQuota;
+    }
+    try {
+        logQuota("Fetching Quota Data...");
+        // Fetch parallèle using HTTPS helper
+        const [profileRes, balanceRes, usageRes] = await Promise.all([
+            fetchAPI('/account/profile', config.apiKey),
+            fetchAPI('/account/balance', config.apiKey),
+            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
+        const resetInfo = calculateResetInfo(profile.nextResetAt);
+        // Calculer l'usage de la période actuelle
+        const { tierUsed } = calculateCurrentPeriodUsage(usage, resetInfo);
+        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é)
+        const walletBalance = Math.max(0, balance - cleanTierRemaining);
+        const cleanWalletBalance = Math.max(0, parseFloat(walletBalance.toFixed(4)));
+        cachedQuota = {
+            tierRemaining: cleanTierRemaining,
+            tierUsed,
+            tierLimit,
+            walletBalance: cleanWalletBalance,
+            nextResetAt: resetInfo.nextReset,
+            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,
+            tier: profile.tier,
+            tierEmoji: tierInfo.emoji
+        };
+        lastQuotaFetch = now;
+        return cachedQuota;
+    }
+    catch (e) {
+        logQuota(`ERROR fetching quota: ${e}`);
+        // 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: '⚠️'
+        };
+    }
+}
+// === HELPERS (Native HTTPS) ===
+function fetchAPI(endpoint, apiKey) {
+    return new Promise((resolve, reject) => {
+        const options = {
+            hostname: 'gen.pollinations.ai',
+            port: 443,
+            path: endpoint,
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'User-Agent': 'opencode-pollinations-plugin/5.1.0'
+            }
+        };
+        const req = https.request(options, (res) => {
+            let data = '';
+            res.on('data', (chunk) => data += chunk);
+            res.on('end', () => {
+                if (res.statusCode && res.statusCode >= 400) {
+                    reject(new Error(`API Error ${res.statusCode}: ${data}`));
+                    return;
+                }
+                try {
+                    const parsed = JSON.parse(data);
+                    resolve(parsed);
+                }
+                catch (e) {
+                    reject(new Error(`JSON Parse Error: ${e.message}`));
+                }
+            });
+        });
+        req.on('error', (e) => {
+            reject(new Error(`Network Error: ${e.message}`));
+        });
+        req.end();
+    });
+}
+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);
+    }
+    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;
+    return {
+        nextReset,
+        lastReset,
+        timeUntilReset,
+        timeSinceReset,
+        resetHour,
+        resetMinute,
+        resetSecond,
+        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);
+        return entryTime >= resetInfo.lastReset;
+    });
+    for (const entry of entriesAfterReset) {
+        if (entry.meter_source === 'tier') {
+            tierUsed += entry.cost_usd;
+        }
+        else if (entry.meter_source === 'pack') {
+            packUsed += entry.cost_usd;
+        }
+    }
+    return { tierUsed, packUsed };
+}
+// === EXPORT POUR LES ALERTES ===
+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));
+    const resetIn = `${hours}h${minutes}m`;
+    return `${quota.tierEmoji} Tier: ${quota.tierRemaining.toFixed(2)}/${quota.tierLimit} (${tierPercent}%) | 💎 Wallet: $${quota.walletBalance.toFixed(2)} | ⏰ Reset: ${resetIn}`;
+}

package/dist/server/router.d.ts

@@ -0,0 +1,8 @@
+export interface RoutingDecision {
+    targetUrl: string;
+    actualModel: string;
+    authHeader?: string;
+    fallbackUsed: boolean;
+    fallbackReason?: string;
+}
+export declare function resolveRouting(requestedModel: string, isAgent?: boolean): Promise<RoutingDecision>;

package/dist/server/router.js

@@ -0,0 +1,122 @@
+import { loadConfig } from './config.js';
+import { getQuotaStatus } from './quota.js';
+import { emitToast } from './toast.js';
+// === MAIN ROUTER ===
+export async function resolveRouting(requestedModel, isAgent = false) {
+    const config = loadConfig();
+    // Normalisation de l'ID modèle pour l'analyse
+    // Peut arriver sous forme: "pollinations/free/gemini" OU "free/gemini"
+    const isEnterprise = requestedModel.includes('/enter/') || requestedModel.startsWith('enter/');
+    const isFree = requestedModel.includes('/free/') || requestedModel.startsWith('free/');
+    // Extraction du "baseModel" (ex: "gemini", "openai")
+    let baseModel = requestedModel;
+    baseModel = baseModel.replace(/^pollinations\//, ''); // Remove plugin prefix
+    baseModel = baseModel.replace(/^(enter|free)\//, ''); // Remove tier prefix
+    // === MODE MANUAL ===
+    if (config.mode === 'manual') {
+        if (isEnterprise && config.apiKey) {
+            return {
+                targetUrl: 'https://gen.pollinations.ai/v1/chat/completions',
+                actualModel: baseModel,
+                authHeader: `Bearer ${config.apiKey}`,
+                fallbackUsed: false
+            };
+        }
+        // Default Free
+        return {
+            targetUrl: 'https://text.pollinations.ai/openai/chat/completions',
+            actualModel: baseModel,
+            authHeader: undefined,
+            fallbackUsed: false
+        };
+    }
+    // === MODES INTELLIGENTS ===
+    if (!config.apiKey) {
+        return {
+            targetUrl: 'https://text.pollinations.ai/openai/chat/completions',
+            actualModel: baseModel,
+            authHeader: undefined,
+            fallbackUsed: false
+        };
+    }
+    const quota = await getQuotaStatus();
+    handleQuotaAlerts(quota, config);
+    // === ALWAYSFREE ===
+    if (config.mode === 'alwaysfree') {
+        if (isEnterprise) {
+            if (quota.tierRemaining > 0) {
+                return {
+                    targetUrl: 'https://gen.pollinations.ai/v1/chat/completions',
+                    actualModel: baseModel,
+                    authHeader: `Bearer ${config.apiKey}`,
+                    fallbackUsed: false
+                };
+            }
+            else {
+                const fallbackModel = isAgent ? config.fallbackModels.agent : config.fallbackModels.main;
+                emitToast('warning', `Quota Free épuisé 🛑 → Relai sur ${fallbackModel} gratuit 🔀`, 'Mode AlwaysFree');
+                return {
+                    targetUrl: 'https://text.pollinations.ai/openai/chat/completions',
+                    actualModel: fallbackModel,
+                    authHeader: undefined,
+                    fallbackUsed: true,
+                    fallbackReason: 'tier_exhausted'
+                };
+            }
+        }
+        // Free
+        return {
+            targetUrl: 'https://text.pollinations.ai/openai/chat/completions',
+            actualModel: baseModel,
+            authHeader: undefined,
+            fallbackUsed: false
+        };
+    }
+    // === PRO ===
+    if (config.mode === 'pro') {
+        if (isEnterprise) {
+            if (quota.canUseEnterprise) {
+                if (quota.isUsingWallet) {
+                    emitToast('info', `Tier épuisé → Utilisation du Wallet ($${quota.walletBalance.toFixed(2)})`, 'Mode Pro');
+                }
+                return {
+                    targetUrl: 'https://gen.pollinations.ai/v1/chat/completions',
+                    actualModel: baseModel,
+                    authHeader: `Bearer ${config.apiKey}`,
+                    fallbackUsed: false
+                };
+            }
+            else {
+                const fallbackModel = isAgent ? config.fallbackModels.agent : config.fallbackModels.main;
+                emitToast('error', `💸 Wallet épuisé ! Fallback sur ${fallbackModel}`, 'Mode Pro');
+                return {
+                    targetUrl: 'https://text.pollinations.ai/openai/chat/completions',
+                    actualModel: fallbackModel,
+                    authHeader: undefined,
+                    fallbackUsed: true,
+                    fallbackReason: 'wallet_exhausted'
+                };
+            }
+        }
+        // Free
+        return {
+            targetUrl: 'https://text.pollinations.ai/openai/chat/completions',
+            actualModel: baseModel,
+            authHeader: undefined,
+            fallbackUsed: false
+        };
+    }
+    // Default
+    return {
+        targetUrl: 'https://text.pollinations.ai/openai/chat/completions',
+        actualModel: baseModel,
+        authHeader: undefined,
+        fallbackUsed: false
+    };
+}
+function handleQuotaAlerts(quota, config) {
+    if (quota.needsAlert && quota.tierLimit > 0) {
+        const tierPercent = Math.round((quota.tierRemaining / quota.tierLimit) * 100);
+        emitToast('warning', `⚠️ Quota Tier à ${tierPercent}%`, 'Alerte Quota');
+    }
+}

package/dist/server/status.d.ts

@@ -0,0 +1,3 @@
+export declare function createStatusHooks(client: any): {
+    'session.idle': () => Promise<void>;
+};

package/dist/server/status.js

@@ -0,0 +1,31 @@
+import { loadConfig } from './config.js';
+import { getQuotaStatus } from './quota.js';
+export function createStatusHooks(client) {
+    return {
+        'session.idle': async () => {
+            const config = loadConfig();
+            // Si la barre de statut est activée via 'status_bar' (bool)
+            // L'utilisateur peut l'activer via /pollinations config status_bar true
+            if (config.statusBar) {
+                const quota = await getQuotaStatus(false);
+                const statusText = formatStatus(quota);
+                try {
+                    // ASTUCE: Toasts longue durée (30s) rafraîchis à chaque idle
+                    // Simule un widget persistent à droite.
+                    await client.tui.showToast({
+                        body: {
+                            message: statusText,
+                            variant: 'info',
+                            duration: 30000
+                        }
+                    });
+                }
+                catch (e) { }
+            }
+        }
+    };
+}
+function formatStatus(quota) {
+    const tierName = quota.tier === 'alwaysfree' ? 'Free' : quota.tier;
+    return `${tierName} ${quota.tierRemaining.toFixed(2)}/${quota.tierLimit} 🌼 | Wallet $${quota.walletBalance.toFixed(2)}`;
+}

package/dist/server/toast.d.ts

@@ -0,0 +1,6 @@
+export declare function setGlobalClient(client: any): void;
+export declare function emitLogToast(type: 'info' | 'warning' | 'error' | 'success', message: string, title?: string): void;
+export declare function emitStatusToast(type: 'info' | 'warning' | 'error' | 'success', message: string, title?: string): void;
+export declare function createToastHooks(client: any): {
+    'session.idle': ({ event }: any) => Promise<void>;
+};

package/dist/server/toast.js

@@ -0,0 +1,78 @@
+import * as fs from 'fs';
+import { loadConfig } from './config.js';
+const toastQueue = [];
+let globalClient = null;
+// === CONFIGURATION ===
+// On charge la config au moment de l'émission pour décider
+// === FONCTIONS PUBLIQUES ===
+export function setGlobalClient(client) {
+    globalClient = client;
+}
+// 1. CANAL LOGS (Technique)
+export function emitLogToast(type, message, title) {
+    const config = loadConfig();
+    const verbosity = config.gui.logs;
+    if (verbosity === 'none')
+        return;
+    if (verbosity === 'error' && type !== 'error' && type !== 'warning')
+        return;
+    // 'verbose' shows all
+    dispatchToast('log', type, message, title || 'Pollinations Log');
+}
+// 2. CANAL STATUS (Dashboard)
+export function emitStatusToast(type, message, title) {
+    const config = loadConfig();
+    const verbosity = config.gui.status;
+    if (verbosity === 'none')
+        return;
+    // 'alert' logic handled by caller (proxy.ts) usually, but we can filter here too? 
+    // Actually, 'all' sends everything. 'alert' sends only warnings/errors.
+    if (verbosity === 'alert' && type !== 'error' && type !== 'warning')
+        return;
+    dispatchToast('status', type, message, title || 'Pollinations Status');
+}
+// INTERNAL DISPATCHER
+function dispatchToast(channel, type, message, title) {
+    const toast = {
+        id: `toast_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        channel,
+        type,
+        title,
+        message,
+        timestamp: Date.now(),
+        displayed: false
+    };
+    toastQueue.push(toast);
+    logToastToFile(toast);
+    if (globalClient) {
+        globalClient.tui.showToast({
+            body: {
+                title: toast.title,
+                message: toast.message,
+                variant: toast.type,
+                duration: channel === 'status' ? 6000 : 4000 // Status stays longer
+            }
+        }).then(() => {
+            toast.displayed = true;
+        }).catch(() => { });
+    }
+    while (toastQueue.length > 20) {
+        toastQueue.shift();
+    }
+}
+// === HELPERS ===
+function logToastToFile(toast) {
+    try {
+        const logLine = `[${new Date(toast.timestamp).toISOString()}] [${toast.channel.toUpperCase()}] [${toast.type.toUpperCase()}] ${toast.message}`;
+        fs.appendFileSync('/tmp/pollinations-toasts.log', logLine + '\n');
+    }
+    catch (e) { }
+}
+export function createToastHooks(client) {
+    return {
+        'session.idle': async ({ event }) => {
+            // Deprecated: We use immediate dispatch now. 
+            // Kept for backward compat if needed or legacy queued items.
+        }
+    };
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+    "name": "opencode-pollinations-plugin",
+    "displayName": "Pollinations AI (V5.1)",
+    "version": "5.1.3",
+    "description": "Native Pollinations.ai Provider Plugin for OpenCode",
+    "publisher": "pollinations",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/fkom13/opencode-pollinations-plugin.git"
+    },
+    "type": "module",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        }
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "engines": {
+        "vscode": "^1.80.0"
+    },
+    "activationEvents": [
+        "onStartupFinished"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "package": "npx vsce package"
+    },
+    "contributes": {
+        "commands": [
+            {
+                "command": "pollinations.mode",
+                "title": "Pollinations: Change Mode"
+            },
+            {
+                "command": "pollinations.usage",
+                "title": "Pollinations: Show Usage"
+            }
+        ]
+    },
+    "files": [
+        "dist"
+    ],
+    "dependencies": {
+        "@opencode-ai/plugin": "^1.0.85",
+        "zod": "^3.22.4"
+    },
+    "devDependencies": {
+        "@types/node": "^20.0.0",
+        "typescript": "^5.0.0"
+    }
+}