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

package/dist/server/commands.js

@@ -202,7 +202,7 @@ async function handleModeCommand(args) {
             return { handled: true, error: `❌ Erreur de vérification: ${e.message}` };
         }
     }
-    // Allow switch (if alwaysfree or manual, or verified pro)
+    // Allow switch (if economy or manual, or verified pro)
     saveConfig({ mode: mode });
     const config = loadConfig();
     if (config.gui.status !== 'none') {
@@ -264,32 +264,36 @@ async function handleUsageCommand(args) {
     }
 }
 function handleFallbackCommand(args) {
-    const [main, agent] = args;
-    if (!main) {
+    const [mode, model] = args;
+    if (!mode) {
         const config = loadConfig();
-        const freeConfig = `Free: main=${config.fallbacks.free.main}, agent=${config.fallbacks.free.agent}`;
-        const enterConfig = `Enter: agent=${config.fallbacks.enter.agent}`;
         return {
             handled: true,
-            response: `Fallbacks actuels:\n${freeConfig}\n${enterConfig}`
+            response: `Fallbacks actuels:\n- Economy: ${config.fallbacks.economy}\n- Pro: ${config.fallbacks.pro}`
         };
     }
-    // Default behavior for "/poll fallback <model> <agent>" is setting FREE fallbacks
-    // User needs to use commands (maybe add /poll fallback enter ...) later
-    // For now, map to Free Fallback as it's the primary Safety Net
     const config = loadConfig();
-    saveConfig({
-        fallbacks: {
-            ...config.fallbacks,
-            free: {
-                main: main,
-                agent: agent || config.fallbacks.free.agent
-            }
-        }
-    });
+    if (mode === 'economy' && model) {
+        saveConfig({
+            fallbacks: { ...config.fallbacks, economy: model }
+        });
+        return {
+            handled: true,
+            response: `✅ Fallback Economy configuré: ${model}`
+        };
+    }
+    if (mode === 'pro' && model) {
+        saveConfig({
+            fallbacks: { ...config.fallbacks, pro: model }
+        });
+        return {
+            handled: true,
+            response: `✅ Fallback Pro configuré: ${model}`
+        };
+    }
     return {
         handled: true,
-        response: `✅ Fallback (Free) configuré: main=${main}, agent=${agent || config.fallbacks.free.agent}`
+        error: `Usage: /pollinations fallback [economy|pro] <modèle>`
     };
 }
 async function handleConnectCommand(args) {
@@ -411,14 +415,23 @@ function handleConfigCommand(args) {
         saveConfig({ thresholds: { ...config.thresholds, tier: threshold } });
         return { handled: true, response: `✅ threshold_tier = ${threshold}%` };
     }
-    if (key === 'threshold_wallet' && value) {
+    if (key === 'threshold_wallet_warn' && value) {
         const threshold = parseInt(value);
         if (isNaN(threshold) || threshold < 0 || threshold > 100) {
             return { handled: true, error: 'Valeur entre 0 et 100 requise' };
         }
         const config = loadConfig();
-        saveConfig({ thresholds: { ...config.thresholds, wallet: threshold } });
-        return { handled: true, response: `✅ threshold_wallet = ${threshold}%` };
+        saveConfig({ thresholds: { ...config.thresholds, wallet_warn: threshold } });
+        return { handled: true, response: `✅ threshold_wallet_warn = ${threshold}%` };
+    }
+    if (key === 'threshold_wallet_stop' && value) {
+        const stopValue = parseFloat(value);
+        if (isNaN(stopValue) || stopValue < 0) {
+            return { handled: true, error: 'Valeur $ positive requise' };
+        }
+        const config = loadConfig();
+        saveConfig({ thresholds: { ...config.thresholds, wallet_stop: stopValue } });
+        return { handled: true, response: `✅ threshold_wallet_stop = $${stopValue}` };
     }
     if (key === 'status_bar' && value) {
         const enabled = value === 'true';
@@ -427,7 +440,7 @@ function handleConfigCommand(args) {
     }
     return {
         handled: true,
-        error: `Clé inconnue: ${key}. Clés: status_gui, logs_gui, threshold_tier, threshold_wallet, status_bar`
+        error: `Clé inconnue: ${key}. Clés: status_gui, logs_gui, threshold_tier, threshold_wallet_warn, threshold_wallet_stop, status_bar`
     };
 }
 function handleHelpCommand() {

package/dist/server/config.d.ts

@@ -1,6 +1,6 @@
-export interface PollinationsConfigV5 {
+export interface PollinationsConfigV6 {
     version: string | number;
-    mode: 'manual' | 'alwaysfree' | 'pro';
+    mode: 'manual' | 'economy' | 'pro';
     apiKey?: string;
     keyHasAccessToProfile?: boolean;
     gui: {
@@ -9,24 +9,24 @@ export interface PollinationsConfigV5 {
     };
     thresholds: {
         tier: number;
-        wallet: number;
+        wallet_warn: number;
+        wallet_stop: number;
     };
     fallbacks: {
-        free: {
-            main: string;
-            agent: string;
-        };
-        enter: {
-            agent: string;
-        };
+        economy: string;
+        pro: string;
+    };
+    session: {
+        wallet_initial?: number;
+        session_start?: string;
     };
     enablePaidTools: boolean;
     statusBar: boolean;
 }
-export declare function loadConfig(): PollinationsConfigV5;
-export declare function saveConfig(updates: Partial<PollinationsConfigV5>): {
+export declare function loadConfig(): PollinationsConfigV6;
+export declare function saveConfig(updates: Partial<PollinationsConfigV6>): {
     version: string;
-    mode: "manual" | "alwaysfree" | "pro";
+    mode: "manual" | "economy" | "pro";
     apiKey?: string;
     keyHasAccessToProfile?: boolean;
     gui: {
@@ -35,17 +35,19 @@ export declare function saveConfig(updates: Partial<PollinationsConfigV5>): {
     };
     thresholds: {
         tier: number;
-        wallet: number;
+        wallet_warn: number;
+        wallet_stop: number;
     };
     fallbacks: {
-        free: {
-            main: string;
-            agent: string;
-        };
-        enter: {
-            agent: string;
-        };
+        economy: string;
+        pro: string;
+    };
+    session: {
+        wallet_initial?: number;
+        session_start?: string;
     };
     enablePaidTools: boolean;
     statusBar: boolean;
 };
+export declare function initSessionWallet(walletBalance: number): void;
+export declare function getWalletWarnPercent(): number;

package/dist/server/config.js

@@ -9,7 +9,7 @@ const CONFIG_DIR_OPENCODE = path.join(HOMEDIR, '.config', 'opencode');
 const OPENCODE_CONFIG_FILE = path.join(CONFIG_DIR_OPENCODE, 'opencode.json');
 const AUTH_FILE = path.join(HOMEDIR, '.local', 'share', 'opencode', 'auth.json');
 // LOAD PACKAGE VERSION
-let PKG_VERSION = '5.2.0';
+let PKG_VERSION = '6.1.0';
 try {
     const pkgPath = path.join(__dirname, '../../package.json');
     if (fs.existsSync(pkgPath)) {
@@ -18,17 +18,22 @@ try {
     }
 }
 catch (e) { }
-const DEFAULT_CONFIG_V5 = {
+const DEFAULT_CONFIG_V6 = {
     version: PKG_VERSION,
-    mode: 'manual',
+    mode: 'economy', // Défaut: economy (protège le wallet)
     gui: { status: 'alert', logs: 'none' },
-    thresholds: { tier: 10, wallet: 5 },
+    thresholds: {
+        tier: 20, // 20% tier restant → alerte/fallback
+        wallet_warn: 20, // 20% wallet restant → alerte (pro)
+        wallet_stop: 0.50 // $0.50 → stop absolu (pro)
+    },
     fallbacks: {
-        free: { main: 'free/mistral', agent: 'free/openai-fast' },
-        enter: { agent: 'free/openai-fast' }
+        economy: 'nova-fast',
+        pro: 'qwen-coder'
     },
+    session: {},
     enablePaidTools: false,
-    keyHasAccessToProfile: true, // Default true for legacy keys
+    keyHasAccessToProfile: true,
     statusBar: true
 };
 function logConfig(msg) {
@@ -40,17 +45,28 @@ function logConfig(msg) {
     }
     catch (e) { }
 }
+// MIGRATION: alwaysfree → economy
+function migrateConfig(config) {
+    if (config.mode === 'alwaysfree') {
+        config.mode = 'economy';
+        logConfig('[Migration] alwaysfree → economy');
+    }
+    // Migrate old fallbacks structure
+    if (config.fallbacks?.free?.main) {
+        config.fallbacks.economy = config.fallbacks.free.main.replace('free/', '');
+        delete config.fallbacks.free;
+        logConfig('[Migration] fallbacks.free → fallbacks.economy');
+    }
+    return config;
+}
 // SIMPLE LOAD (Direct Disk Read - No Caching, No Watchers)
-// This ensures the Proxy ALWAYS sees the latest state from auth.json
 export function loadConfig() {
     return readConfigFromDisk();
 }
 function readConfigFromDisk() {
-    let config = { ...DEFAULT_CONFIG_V5 };
+    let config = { ...DEFAULT_CONFIG_V6 };
     let finalKey = undefined;
     let source = 'none';
-    // TIMESTAMP BASED PRIORITY LOGIC
-    // We want the most recently updated Valid Key to win.
     let configTime = 0;
     let authTime = 0;
     try {
@@ -69,7 +85,7 @@ function readConfigFromDisk() {
         try {
             const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
             const custom = JSON.parse(raw);
-            config = { ...config, ...custom }; // Helper: We load the rest of config anyway
+            config = { ...config, ...migrateConfig(custom) };
             if (custom.apiKey && custom.apiKey.length > 5)
                 configKey = custom.apiKey;
         }
@@ -90,7 +106,6 @@ function readConfigFromDisk() {
         catch (e) { }
     }
     // 2. DETERMINE WINNER
-    // If both exist, newest wins. If one exists, it wins.
     if (configKey && authKey) {
         if (configTime >= authTime) {
             finalKey = configKey;
@@ -128,16 +143,9 @@ function readConfigFromDisk() {
     // 4. APPLY
     if (finalKey) {
         config.apiKey = finalKey;
-        // config.mode = 'pro'; // REMOVED: Mode is decoupled from Key presence.
     }
     else {
-        // Ensure no phantom key remains
         delete config.apiKey;
-        // if (config.mode === 'pro') config.mode = 'manual'; // OPTIONAL: Downgrade if no key? User says "No link".
-        // Actually, if I am in PRO mode and lose my key, I am broken. Falling back to manual is safer?
-        // User said "Manual mode is like standard API".
-        // Let's REMOVE this auto-downgrade too to be strictly "Decoupled".
-        // If user is in PRO without key, they get "Missing Key" error, which is correct.
     }
     return { ...config, version: PKG_VERSION };
 }
@@ -149,6 +157,7 @@ export function saveConfig(updates) {
             fs.mkdirSync(CONFIG_DIR_POLLI, { recursive: true });
         }
         fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2));
+        logConfig(`[SaveConfig] Updated: ${Object.keys(updates).join(', ')}`);
         return updated;
     }
     catch (e) {
@@ -156,3 +165,23 @@ export function saveConfig(updates) {
         throw e;
     }
 }
+// SESSION WALLET TRACKING
+export function initSessionWallet(walletBalance) {
+    const config = loadConfig();
+    if (!config.session.wallet_initial) {
+        saveConfig({
+            session: {
+                wallet_initial: walletBalance,
+                session_start: new Date().toISOString()
+            }
+        });
+        logConfig(`[Session] Wallet initial stocké: $${walletBalance}`);
+    }
+}
+export function getWalletWarnPercent() {
+    const config = loadConfig();
+    const initial = config.session.wallet_initial;
+    if (!initial || initial <= 0)
+        return 100; // No reference = no warning
+    return config.thresholds.wallet_warn;
+}

package/dist/server/proxy.js

@@ -245,13 +245,8 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                         if (quota.walletBalance <= 0.001) { // Floating point safety
                             log(`[SafetyNet] Paid Only Model (${actualModel}) requested but Wallet is Empty ($${quota.walletBalance}). BLOCKING.`);
                             // Immediate Block or Fallback?
-                            // Text says: "💎 Paid Only models require purchased pollen only"
-                            // Blocking is safer/clearer than falling back to a free model which might not be what the user expects for a "Pro" feature?
-                            // Actually, Fallback to Free is usually better for UX if configured, BUT for specific "Paid Only" requests, the user explicitly chose a powerful model.
-                            // Falling back to Mistral might be confusing if they asked for Gemini-Large.
-                            // BUT we are failing gracefully.
-                            // Let's Fallback to Free Default and Warn.
-                            actualModel = config.fallbacks.free.main.replace('free/', '');
+                            // Fallback based on current mode
+                            actualModel = config.fallbacks.economy || 'nova-fast';
                             isEnterprise = false;
                             isFallbackActive = true;
                             fallbackReason = "Paid Only Model requires purchased credits";
@@ -277,62 +272,113 @@ export async function handleChatCompletion(req, res, bodyRaw) {
             // WE DO NOT RETURN 403. WE ALLOW THE REQUEST.
             // Since config.mode is now 'manual', the next checks (alwaysfree/pro) will be skipped.
         }
-        if (config.mode === 'alwaysfree') {
+        // === MODE ECONOMY ===
+        // - Paid models BLOCKED (not fallback, BLOCK with message)
+        // - tier < threshold → fallback economy
+        // - tier = 0 → STOP (no wallet access)
+        if (config.mode === 'economy') {
             if (isEnterprise) {
-                // NEW: Paid Only Check for Always Free
+                // 1. BLOCK Paid Models
                 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(`[Economy] BLOCKED: Paid model ${actualModel} not allowed in Economy mode`);
+                            emitStatusToast('error', `💎 Modèle payant interdit en mode Economy: ${actualModel}`, 'Mode Economy');
+                            res.writeHead(403, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({
+                                error: {
+                                    message: `💎 Paid model "${actualModel}" is not allowed in Economy mode. Switch to Pro mode or use a free model.`,
+                                    code: 'ECONOMY_PAID_BLOCKED'
+                                }
+                            }));
+                            return;
                         }
                     }
                 }
-                catch (e) { }
-                if (!isFallbackActive && quota.tier === 'error') {
-                    // Network error or unknown error (but NOT auth_limited, handled above)
-                    log(`[SafetyNet] AlwaysFree Mode: Quota Check Failed. Switching to Free Fallback.`);
-                    actualModel = config.fallbacks.free.main.replace('free/', '');
-                    isEnterprise = false;
+                catch (e) {
+                    log(`[Economy] Error checking paid models: ${e}`);
+                }
+                // 2. Check Tier
+                if (quota.tier === 'error') {
+                    log(`[Economy] Quota unreachable, switching to fallback`);
+                    actualModel = config.fallbacks.economy || 'nova-fast';
                     isFallbackActive = true;
                     fallbackReason = "Quota Unreachable (Safety)";
                 }
                 else {
                     const tierRatio = quota.tierLimit > 0 ? (quota.tierRemaining / quota.tierLimit) : 0;
+                    // 3. STOP if tier = 0
+                    if (quota.tierRemaining <= 0.01) {
+                        log(`[Economy] STOP: Tier exhausted, no wallet access in Economy mode`);
+                        emitStatusToast('error', `🛑 Quota épuisé! Attendez le reset ou passez en mode Pro.`, 'Mode Economy');
+                        res.writeHead(429, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({
+                            error: {
+                                message: `🛑 Daily quota exhausted. Wait for reset or switch to Pro mode to use wallet credits.`,
+                                code: 'ECONOMY_TIER_EXHAUSTED'
+                            }
+                        }));
+                        return;
+                    }
+                    // 4. Fallback if tier < threshold
                     if (tierRatio <= (config.thresholds.tier / 100)) {
-                        log(`[SafetyNet] AlwaysFree Mode: Tier (${(tierRatio * 100).toFixed(1)}%) <= Threshold (${config.thresholds.tier}%). Switching.`);
-                        actualModel = config.fallbacks.free.main.replace('free/', '');
-                        isEnterprise = false;
+                        log(`[Economy] Tier ${(tierRatio * 100).toFixed(1)}% <= ${config.thresholds.tier}%, switching to fallback`);
+                        actualModel = config.fallbacks.economy || 'nova-fast';
                         isFallbackActive = true;
-                        fallbackReason = `Daily Tier < ${config.thresholds.tier}% (Wallet Protected)`;
+                        fallbackReason = `Tier < ${config.thresholds.tier}% (Economie active)`;
                     }
                 }
             }
         }
+        // === MODE PRO ===
+        // - Paid models ALLOWED
+        // - wallet < wallet_stop $ → STOP
+        // - wallet < wallet_warn % → fallback pro
+        // - tier exhausted → info toast (continue on wallet)
         else if (config.mode === 'pro') {
             if (isEnterprise) {
+                // Init session wallet tracking (first request)
+                if (!config.session?.wallet_initial && quota.walletBalance > 0) {
+                    const { initSessionWallet } = await import('./config.js');
+                    initSessionWallet(quota.walletBalance);
+                }
                 if (quota.tier === 'error') {
-                    // Network error or unknown
-                    log(`[SafetyNet] Pro Mode: Quota Unreachable. Switching to Free Fallback.`);
-                    actualModel = config.fallbacks.free.main.replace('free/', '');
-                    isEnterprise = false;
+                    log(`[Pro] Quota unreachable, switching to fallback`);
+                    actualModel = config.fallbacks.pro || 'qwen-coder';
                     isFallbackActive = true;
                     fallbackReason = "Quota Unreachable (Safety)";
                 }
                 else {
-                    const tierRatio = quota.tierLimit > 0 ? (quota.tierRemaining / quota.tierLimit) : 0;
-                    if (quota.walletBalance < config.thresholds.wallet && tierRatio <= (config.thresholds.tier / 100)) {
-                        log(`[SafetyNet] Pro Mode: Wallet < $${config.thresholds.wallet} AND Tier < ${config.thresholds.tier}%. Switching.`);
-                        actualModel = config.fallbacks.free.main.replace('free/', '');
-                        isEnterprise = false;
+                    const walletStop = config.thresholds.wallet_stop || 0.50;
+                    const walletWarnPercent = config.thresholds.wallet_warn || 20;
+                    const walletInitial = config.session?.wallet_initial || quota.walletBalance;
+                    const walletPercent = walletInitial > 0 ? (quota.walletBalance / walletInitial) * 100 : 100;
+                    // 1. STOP if wallet < wallet_stop $
+                    if (quota.walletBalance < walletStop) {
+                        log(`[Pro] STOP: Wallet $${quota.walletBalance} < limit $${walletStop}`);
+                        emitStatusToast('error', `🛑 Wallet $${quota.walletBalance.toFixed(2)} sous limite $${walletStop}`, 'Mode Pro');
+                        res.writeHead(429, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({
+                            error: {
+                                message: `🛑 Wallet ($${quota.walletBalance.toFixed(2)}) below hard limit ($${walletStop}). Add credits or adjust wallet_stop threshold.`,
+                                code: 'PRO_WALLET_LIMIT'
+                            }
+                        }));
+                        return;
+                    }
+                    // 2. Fallback if wallet% < wallet_warn%
+                    if (walletPercent <= walletWarnPercent) {
+                        log(`[Pro] Wallet ${walletPercent.toFixed(1)}% <= ${walletWarnPercent}%, switching to fallback`);
+                        actualModel = config.fallbacks.pro || 'qwen-coder';
                         isFallbackActive = true;
-                        fallbackReason = `Wallet & Tier Critical`;
+                        fallbackReason = `Wallet < ${walletWarnPercent}% (${quota.walletBalance.toFixed(2)}$)`;
+                    }
+                    // 3. Info if tier exhausted (continue on wallet)
+                    if (quota.tierRemaining <= 0.01 && !isFallbackActive) {
+                        emitStatusToast('info', `ℹ️ Tier épuisé, utilisation du wallet ($${quota.walletBalance.toFixed(2)})`, 'Mode Pro');
                     }
                 }
             }
@@ -563,8 +609,10 @@ export async function handleChatCompletion(req, res, bodyRaw) {
             if ((isEnterpriseFallback || isGeminiToolsFallback) && config.mode !== 'manual') {
                 log(`[SafetyNet] Upstream Rejection (${fetchRes.status}). Triggering Transparent Fallback.`);
                 if (isEnterpriseFallback) {
-                    // 1a. Enterprise -> Free Fallback
-                    actualModel = config.fallbacks.free.main.replace('free/', '');
+                    // 1a. Enterprise -> Fallback based on mode
+                    actualModel = config.mode === 'pro'
+                        ? (config.fallbacks.pro || 'qwen-coder')
+                        : (config.fallbacks.economy || 'nova-fast');
                     isEnterprise = false;
                     isFallbackActive = true;
                     if (fetchRes.status === 402)

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "opencode-pollinations-plugin",
     "displayName": "Pollinations AI (V5.6)",
-    "version": "6.0.0",
+    "version": "6.1.0-beta.1",
     "description": "Native Pollinations.ai Provider Plugin for OpenCode",
     "publisher": "pollinations",
     "repository": {