opencode-pollinations-plugin 5.5.0-debug.3 → 5.5.0

package/README.md

@@ -1,4 +1,4 @@
-# 🌸 Pollinations AI Plugin for OpenCode (v5.4.6)
+# 🌸 Pollinations AI Plugin for OpenCode (v5.4.16)
 
 <div align="center">
   <img src="https://avatars.githubusercontent.com/u/88394740?s=400&v=4" alt="Pollinations.ai Logo" width="200">
@@ -10,7 +10,7 @@
 
 <div align="center">
 
-![Version](https://img.shields.io/badge/version-5.4.6-blue.svg)
+![Version](https://img.shields.io/badge/version-5.4.16-blue.svg)
 ![License](https://img.shields.io/badge/license-MIT-green.svg)
 ![Status](https://img.shields.io/badge/status-Stable-success.svg)
 
@@ -45,6 +45,19 @@ Pollinations.ai is an open-source platform built by and for the community. We pr
   <em>Wide Range of Models (Mistral, OpenAI, Gemini, Claude)</em>
 </p>
 
+<p align="center">
+  <img src="https://github.com/fkom13/opencode-pollinations-plugin/raw/main/docs/images/free_add.png" alt="Free Chat Example" width="800">
+  <br>
+  <em>Free Universe Chat (Supported by Pollinations Ads)</em>
+</p>
+
+<p align="center">
+  <img src="https://github.com/fkom13/opencode-pollinations-plugin/raw/main/docs/images/plan_1.png" alt="Plan Build Step 1" width="400">
+  <img src="https://github.com/fkom13/opencode-pollinations-plugin/raw/main/docs/images/plan_2.png" alt="Plan Build Step 2" width="400">
+  <br>
+  <em>Integrated Plan Building Workflow</em>
+</p>
+
 ## ✨ Features
 
 - **🌍 Free Universe**: Access generic models (`openai`, `mistral`, `gemini`) for **FREE**, unlimited time, no API key required.
@@ -133,6 +146,11 @@ Just type in the chat. You are in **Manual Mode** by default.
 
 ### 🤖 Models
 
+### 🔑 Types de Clés Supportés
+- **Clés Standard (`sk-...`)**: Accès complet (Modèles + Dashboard Usage + Quota).
+- **Clés Limitées**: Accès Génération uniquement. Le dashboard affichera une alerte de restriction (v5.4.11).
+- **Support Legacy**: Les anciennes clés (`sk_...`) sont aussi acceptées.
+
 ## 🔗 Links
 
 - **Pollinations Website**: [pollinations.ai](https://pollinations.ai)
@@ -142,3 +160,9 @@ Just type in the chat. You are in **Manual Mode** by default.
 ## 📜 License
 
 MIT License. Created by [fkom13](https://github.com/fkom13) & The Pollinations Community.
+### 🛡️ Clés API Limitées
+
+Si vous utilisez un token API restreint (ex: création d'une clé **sans** les permissions `Profile`, `Balance` ou `Usage`), le plugin passera automatiquement en mode **Manual**.
+
+- **Mode Forcé** : `Manual` (Les modes `Pro` et `AlwaysFree` sont désactivés pour ces clés car ils nécessitent l'accès au quota pour fonctionner).
+- **Conséquence** : Pas de Dashboard, pas de Safety Nets, mais génération fonctionnelle sur les modèles autorisés.

package/dist/server/commands.js

@@ -2,6 +2,40 @@ import { loadConfig, saveConfig } from './config.js';
 import { getQuotaStatus } from './quota.js';
 import { emitStatusToast } from './toast.js';
 import { getDetailedUsage } from './pollinations-api.js';
+import { generatePollinationsConfig } from './generate-config.js';
+import * as https from 'https';
+// --- HELPER: STRICT PERMISSION CHECK ---
+function checkKeyPermissions(key) {
+    return new Promise((resolve) => {
+        // We need Usage, Profile AND Balance for "Managed Modes"
+        // If any of these fail (403), the key is Limited.
+        const endpoints = ['/account/profile', '/account/balance', '/account/usage'];
+        let successCount = 0;
+        let completed = 0;
+        endpoints.forEach(ep => {
+            const req = https.request({
+                hostname: 'gen.pollinations.ai',
+                path: ep,
+                method: 'GET',
+                headers: { 'Authorization': `Bearer ${key}` }
+            }, (res) => {
+                completed++;
+                if (res.statusCode === 200)
+                    successCount++;
+                if (completed === endpoints.length) {
+                    resolve(successCount === endpoints.length);
+                }
+            });
+            req.on('error', () => {
+                completed++;
+                if (completed === endpoints.length)
+                    resolve(successCount === endpoints.length);
+            });
+            req.setTimeout(5000, () => req.destroy());
+            req.end();
+        });
+    });
+}
 // === CONSTANTS & PRICING ===
 const TIER_LIMITS = {
     spore: { pollen: 1, emoji: '🦠' },
@@ -89,6 +123,8 @@ export async function handleCommand(command) {
             return handleModeCommand(args);
         case 'usage':
             return await handleUsageCommand(args);
+        case 'connect':
+            return handleConnectCommand(args);
         case 'fallback':
             return handleFallbackCommand(args);
         case 'config':
@@ -118,9 +154,17 @@ function handleModeCommand(args) {
             error: `Mode invalide: ${mode}. Valeurs: manual, alwaysfree, pro`
         };
     }
+    const currentConfig = loadConfig();
+    // RESTRICTED KEY LOGIC: Block Managed Modes if key is limited
+    if (currentConfig.keyHasAccessToProfile === false && (mode === 'alwaysfree' || mode === 'pro')) {
+        return {
+            handled: true,
+            error: `❌ **Mode Refusé**: Votre clé API est "Limitée" (Pas d'accès Profile/Usage).\n\nLes modes gérés (Pro/AlwaysFree) nécessitent un accès au Quota pour fonctionner.\nRestez en mode **Manual** ou utilisez une clé avec permissions complètes.`
+        };
+    }
     saveConfig({ mode: mode });
-    const config = loadConfig();
-    if (config.gui.status !== 'none') {
+    const newConfig = loadConfig();
+    if (newConfig.gui.status !== 'none') {
         emitStatusToast('success', `Mode changé vers: ${mode}`, 'Pollinations Config');
     }
     return {
@@ -144,21 +188,26 @@ async function handleUsageCommand(args) {
         response += `- **Wallet**: $${quota.walletBalance.toFixed(2)}\n`;
         response += `- **Reset**: ${resetDate} (dans ${durationStr})\n`;
         if (isFull && config.apiKey) {
-            const usageData = await getDetailedUsage(config.apiKey);
-            if (usageData && usageData.usage) {
-                const lastReset = calculateResetDate(quota.nextResetAt);
-                const stats = calculateCurrentPeriodStats(usageData.usage, lastReset, quota.tierLimit);
-                response += `\n### 📊 Détail Période (depuis ${lastReset.toLocaleTimeString()})\n`;
-                response += `**Total Requêtes**: ${stats.totalRequests} | **Tokens**: In ${formatTokens(stats.inputTokens)} / Out ${formatTokens(stats.outputTokens)}\n\n`;
-                response += `| Modèle | Reqs | Coût | Tokens |\n`;
-                response += `| :--- | :---: | :---: | :---: |\n`;
-                const sorted = Array.from(stats.models.entries()).sort((a, b) => b[1].cost - a[1].cost);
-                for (const [model, data] of sorted) {
-                    response += `| \`${model}\` | ${data.requests} | ${formatPollen(data.cost)} | ${formatTokens(data.inputTokens + data.outputTokens)} |\n`;
-                }
+            if (config.keyHasAccessToProfile === false) {
+                response += `\n> ⚠️ *Votre clé API ne permet pas l'accès aux détails d'usage (Restriction).*`;
             }
             else {
-                response += `\n> ⚠️ *Impossible de récupérer l'historique détaillé.*\n`;
+                const usageData = await getDetailedUsage(config.apiKey);
+                if (usageData && usageData.usage) {
+                    const lastReset = calculateResetDate(quota.nextResetAt);
+                    const stats = calculateCurrentPeriodStats(usageData.usage, lastReset, quota.tierLimit);
+                    response += `\n### 📊 Détail Période (depuis ${lastReset.toLocaleTimeString()})\n`;
+                    response += `**Total Requêtes**: ${stats.totalRequests} | **Tokens**: In ${formatTokens(stats.inputTokens)} / Out ${formatTokens(stats.outputTokens)}\n\n`;
+                    response += `| Modèle | Reqs | Coût | Tokens |\n`;
+                    response += `| :--- | :---: | :---: | :---: |\n`;
+                    const sorted = Array.from(stats.models.entries()).sort((a, b) => b[1].cost - a[1].cost);
+                    for (const [model, data] of sorted) {
+                        response += `| \`${model}\` | ${data.requests} | ${formatPollen(data.cost)} | ${formatTokens(data.inputTokens + data.outputTokens)} |\n`;
+                    }
+                }
+                else {
+                    response += `\n> ⚠️ *Impossible de récupérer l'historique détaillé.*\n`;
+                }
             }
         }
         else if (isFull) {
@@ -174,31 +223,112 @@ async function handleUsageCommand(args) {
     }
 }
 function handleFallbackCommand(args) {
-    const [primary, subagent] = args;
-    if (!primary) {
+    const [main, agent] = args;
+    if (!main) {
         const config = loadConfig();
-        const freeConfig = `Free Fallbacks: primary=${config.fallbacks.free.primary}, subagent=${config.fallbacks.free.subagent}`;
-        const enterConfig = `Enter Targets: subagent=${config.fallbacks.enter.subagent}`;
+        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: `Configuration des Modèles:\n${freeConfig}\n${enterConfig}`
+            response: `Fallbacks actuels:\n${freeConfig}\n${enterConfig}`
         };
     }
+    // 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: {
-                primary: primary,
-                subagent: subagent || config.fallbacks.free.subagent
+                main: main,
+                agent: agent || config.fallbacks.free.agent
             }
         }
     });
     return {
         handled: true,
-        response: `✅ Fallbacks configurés: primary=${primary}, subagent=${subagent || config.fallbacks.free.subagent}`
+        response: `✅ Fallback (Free) configuré: main=${main}, agent=${agent || config.fallbacks.free.agent}`
     };
 }
+async function handleConnectCommand(args) {
+    const key = args[0];
+    if (!key) {
+        return {
+            handled: true,
+            error: `Utilisation: /pollinations connect <votre_clé_api>`
+        };
+    }
+    // 1. Universal Validation (No Syntax Check) - Functional Check
+    emitStatusToast('info', 'Vérification de la clé...', 'Pollinations Config');
+    try {
+        const models = await generatePollinationsConfig(key, true);
+        // 2. Check if we got Enterprise models
+        const enterpriseModels = models.filter(m => m.id.startsWith('enter/'));
+        if (enterpriseModels.length > 0) {
+            // SUCCESS
+            saveConfig({ apiKey: key }); // Don't force mode 'pro'. Let user decide.
+            const masked = key.substring(0, 6) + '...';
+            // count Paid Only models found
+            const diamondCount = enterpriseModels.filter(m => m.name.includes('💎')).length;
+            // CHECK RESTRICTIONS: Strict Check (Usage + Profile + Balance)
+            let forcedModeMsg = "";
+            let isLimited = false;
+            try {
+                // Strict Probe: Must be able to read ALL accounting data
+                const hasFullAccess = await checkKeyPermissions(key);
+                isLimited = !hasFullAccess;
+            }
+            catch (e) {
+                isLimited = true;
+            }
+            // If Limited -> FORCE MANUAL
+            if (isLimited) {
+                saveConfig({ apiKey: key, mode: 'manual', keyHasAccessToProfile: false });
+                forcedModeMsg = "\n⚠️ **Clé Limitée** (Permissions insuffisantes) -> Mode **MANUAL** forcé.\n*Requis pour mode Auto: Profile, Balance & Usage.*";
+            }
+            else {
+                saveConfig({ apiKey: key, keyHasAccessToProfile: true }); // Let user keep current mode or default
+            }
+            emitStatusToast('success', `Clé Valide! (${enterpriseModels.length} modèles Pro débloqués)`, 'Pollinations Config');
+            return {
+                handled: true,
+                response: `✅ **Connexion Réussie!**\n- Clé: \`${masked}\`\n- Modèles Débloqués: ${enterpriseModels.length} (dont ${diamondCount} 💎 Paid)${forcedModeMsg}`
+            };
+        }
+        else {
+            // FAILURE (Valid JSON but no Enterprise models - likely Invalid Key or Free plan only?)
+            // If key is invalid, generatePollinationsConfig usually returns fallback free models BUT
+            // we specifically checked 'enter/'. If 0 enterprise models found for a *provided* key, it's suspicious.
+            // Actually config generator returns Free models + Enter models if key works.
+            // If key is BAD, fetchJson throws/logs error, and returns fallbacks (Enter GPT-4o Fallback).
+            // Wait, generate-config falls back to providing a list containing "[Enter] GPT-4o (Fallback)" if fetch failed.
+            // So we need to detect if it's a "REAL" fetch or a "FALLBACK" fetch.
+            // The fallback models have `variants: {}` usually, but real ones might too.
+            // A better check: The fallback list is hardcoded in generate-config.ts catch block.
+            // Let's modify generate-config to return EMPTY list on error?
+            // Or just check if the returned models work?
+            // Simplest: If `generatePollinationsConfig` returns any model starting with `enter/` that includes "(Fallback)" in name, we assume failure?
+            // "GPT-4o (Fallback)" is the name.
+            const isFallback = models.some(m => m.name.includes('(Fallback)') && m.id.startsWith('enter/'));
+            if (isFallback) {
+                throw new Error("Clé rejetée par l'API (Accès refusé ou invalide).");
+            }
+            // If we are here, we got no enter models, or empty list?
+            // If key is valid but has no access?
+            throw new Error("Aucun modèle Enterprise détecté pour cette clé.");
+        }
+    }
+    catch (e) {
+        // 3. FAILURE HANDLING - Revert to FREE
+        saveConfig({ apiKey: undefined, mode: 'manual' }); // Clear Key, Set Manual
+        emitStatusToast('error', `Clé Invalide. Retour au mode Gratuit.`, 'Pollinations Config');
+        return {
+            handled: true,
+            error: `❌ **Échec Connexion**: ${e.message || e}\n\nLa configuration a été réinitialisée (Mode Gratuit/Manuel).`
+        };
+    }
+}
 function handleConfigCommand(args) {
     const [key, value] = args;
     if (!key) {
@@ -270,7 +400,7 @@ function handleHelpCommand() {
 
 - **\`/pollinations mode [mode]\`**: Change le mode (manual, alwaysfree, pro).
 - **\`/pollinations usage [full]\`**: Affiche le dashboard (full = détail).
-- **\`/pollinations fallback <primary> [subagent]\`**: Configure le Safety Net (Free).
+- **\`/pollinations fallback <main> [agent]\`**: Configure le Safety Net (Free).
 - **\`/pollinations config [key] [value]\`**:
   - \`status_gui\`: none, alert, all (Status Dashboard).
   - \`logs_gui\`: none, error, verbose (Logs Techniques).

package/dist/server/config.d.ts

@@ -2,6 +2,7 @@ export interface PollinationsConfigV5 {
     version: string | number;
     mode: 'manual' | 'alwaysfree' | 'pro';
     apiKey?: string;
+    keyHasAccessToProfile?: boolean;
     gui: {
         status: 'none' | 'alert' | 'all';
         logs: 'none' | 'error' | 'verbose';
@@ -12,11 +13,11 @@ export interface PollinationsConfigV5 {
     };
     fallbacks: {
         free: {
-            primary: string;
-            subagent: string;
+            main: string;
+            agent: string;
         };
         enter: {
-            subagent: string;
+            agent: string;
         };
     };
     enablePaidTools: boolean;
@@ -27,6 +28,7 @@ export declare function saveConfig(updates: Partial<PollinationsConfigV5>): {
     version: string;
     mode: "manual" | "alwaysfree" | "pro";
     apiKey?: string;
+    keyHasAccessToProfile?: boolean;
     gui: {
         status: "none" | "alert" | "all";
         logs: "none" | "error" | "verbose";
@@ -37,11 +39,11 @@ export declare function saveConfig(updates: Partial<PollinationsConfigV5>): {
     };
     fallbacks: {
         free: {
-            primary: string;
-            subagent: string;
+            main: string;
+            agent: string;
         };
         enter: {
-            subagent: string;
+            agent: string;
         };
     };
     enablePaidTools: boolean;

package/dist/server/config.js

@@ -9,11 +9,13 @@ 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.5.0';
+let PKG_VERSION = '5.2.0';
 try {
-    const pkgPath = new URL('../../package.json', import.meta.url);
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-    PKG_VERSION = pkg.version;
+    const pkgPath = path.join(__dirname, '../../package.json');
+    if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        PKG_VERSION = pkg.version;
+    }
 }
 catch (e) { }
 const DEFAULT_CONFIG_V5 = {
@@ -22,10 +24,11 @@ const DEFAULT_CONFIG_V5 = {
     gui: { status: 'alert', logs: 'none' },
     thresholds: { tier: 10, wallet: 5 },
     fallbacks: {
-        free: { primary: 'free/mistral', subagent: 'free/openai-fast' },
-        enter: { subagent: 'default' }
+        free: { main: 'free/mistral', agent: 'free/openai-fast' },
+        enter: { agent: 'free/openai-fast' }
     },
     enablePaidTools: false,
+    keyHasAccessToProfile: true, // Default true for legacy keys
     statusBar: true
 };
 function logConfig(msg) {
@@ -38,65 +41,76 @@ function logConfig(msg) {
     catch (e) { }
 }
 // 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 keyFound = false;
-    // 1. Custom Config
+    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 {
-        if (fs.existsSync(CONFIG_FILE)) {
+        if (fs.existsSync(CONFIG_FILE))
+            configTime = fs.statSync(CONFIG_FILE).mtime.getTime();
+    }
+    catch (e) { }
+    try {
+        if (fs.existsSync(AUTH_FILE))
+            authTime = fs.statSync(AUTH_FILE).mtime.getTime();
+    }
+    catch (e) { }
+    // 1. EXTRACT KEYS
+    let configKey = undefined;
+    if (fs.existsSync(CONFIG_FILE)) {
+        try {
             const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
             const custom = JSON.parse(raw);
-            // MIGRATION LOGIC (v5.5.0)
-            if (custom.fallbacks) {
-                if (custom.fallbacks.free) {
-                    if (custom.fallbacks.free.main) {
-                        custom.fallbacks.free.primary = custom.fallbacks.free.main;
-                        delete custom.fallbacks.free.main;
-                    }
-                    if (custom.fallbacks.free.agent) {
-                        custom.fallbacks.free.subagent = custom.fallbacks.free.agent;
-                        delete custom.fallbacks.free.agent;
-                    }
-                }
-                if (custom.fallbacks.enter && custom.fallbacks.enter.agent) {
-                    custom.fallbacks.enter.subagent = custom.fallbacks.enter.agent;
-                    delete custom.fallbacks.enter.agent;
-                }
-            }
-            config = { ...config, ...custom };
-            if (config.apiKey)
-                keyFound = true;
+            config = { ...config, ...custom }; // Helper: We load the rest of config anyway
+            if (custom.apiKey && custom.apiKey.length > 5)
+                configKey = custom.apiKey;
         }
+        catch (e) { }
     }
-    catch (e) {
-        logConfig(`Error loading config: ${e}`);
-    }
-    // 2. Auth Store (Priority)
-    if (!keyFound) {
+    let authKey = undefined;
+    if (fs.existsSync(AUTH_FILE)) {
         try {
-            if (fs.existsSync(AUTH_FILE)) {
-                const raw = fs.readFileSync(AUTH_FILE, 'utf-8');
-                const authData = JSON.parse(raw);
-                const entry = authData['pollinations'] || authData['pollinations_enter'] || authData['pollinations_api_key'];
-                if (entry) {
-                    const key = (typeof entry === 'object' && entry.key) ? entry.key : entry;
-                    if (key && typeof key === 'string' && key.length > 10) {
-                        config.apiKey = key;
-                        config.mode = 'pro';
-                        keyFound = true;
-                    }
-                }
+            const raw = fs.readFileSync(AUTH_FILE, 'utf-8');
+            const authData = JSON.parse(raw);
+            const entry = authData['pollinations'] || authData['pollinations_enter'] || authData['pollinations_api_key'];
+            if (entry) {
+                const k = (typeof entry === 'object' && entry.key) ? entry.key : entry;
+                if (k && typeof k === 'string' && k.length > 10)
+                    authKey = k;
             }
         }
-        catch (e) {
-            logConfig(`Error reading auth.json: ${e}`);
+        catch (e) { }
+    }
+    // 2. DETERMINE WINNER
+    // If both exist, newest wins. If one exists, it wins.
+    if (configKey && authKey) {
+        if (configTime >= authTime) {
+            finalKey = configKey;
+            source = 'config.json';
+        }
+        else {
+            finalKey = authKey;
+            source = 'auth.json';
         }
     }
-    // 3. OpenCode Config (Fallback)
-    if (!keyFound) {
+    else if (configKey) {
+        finalKey = configKey;
+        source = 'config.json';
+    }
+    else if (authKey) {
+        finalKey = authKey;
+        source = 'auth.json';
+    }
+    // 3. Fallback to OpenCode Global Config (Lowest Priority)
+    if (!finalKey) {
         try {
             if (fs.existsSync(OPENCODE_CONFIG_FILE)) {
                 const raw = fs.readFileSync(OPENCODE_CONFIG_FILE, 'utf-8');
@@ -104,16 +118,26 @@ function readConfigFromDisk() {
                 const nativeKey = data?.provider?.pollinations?.options?.apiKey ||
                     data?.provider?.pollinations_enter?.options?.apiKey;
                 if (nativeKey && nativeKey.length > 5 && nativeKey !== 'dummy') {
-                    config.apiKey = nativeKey;
-                    config.mode = 'pro';
-                    keyFound = true;
+                    finalKey = nativeKey;
+                    source = 'opencode.json';
                 }
             }
         }
         catch (e) { }
     }
-    if (!keyFound && config.mode === 'pro') {
-        config.mode = 'manual';
+    // 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 };
 }

package/dist/server/generate-config.d.ts

@@ -9,5 +9,5 @@ interface OpenCodeModel {
         output?: number;
     };
 }
-export declare function generatePollinationsConfig(forceApiKey?: string): Promise<OpenCodeModel[]>;
+export declare function generatePollinationsConfig(forceApiKey?: string, forceStrict?: boolean): Promise<OpenCodeModel[]>;
 export {};

package/dist/server/generate-config.js

@@ -1,6 +1,11 @@
 import * as https from 'https';
 import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
 import { loadConfig } from './config.js';
+const HOMEDIR = os.homedir();
+const CONFIG_DIR_POLLI = path.join(HOMEDIR, '.pollinations');
+const CONFIG_FILE = path.join(CONFIG_DIR_POLLI, 'config.json');
 // --- LOGGING ---
 const LOG_FILE = '/tmp/opencode_pollinations_config.log';
 function log(msg) {
@@ -49,7 +54,7 @@ function formatName(id, censored = true) {
 }
 // --- MAIN GENERATOR logic ---
 // --- MAIN GENERATOR logic ---
-export async function generatePollinationsConfig(forceApiKey) {
+export async function generatePollinationsConfig(forceApiKey, forceStrict = false) {
     const config = loadConfig();
     const modelsOutput = [];
     log(`Starting Configuration (V5.1.22 Hot-Reload)...`);
@@ -74,12 +79,8 @@ export async function generatePollinationsConfig(forceApiKey) {
         modelsOutput.push({ id: "free/gemini", name: "[Free] Gemini Flash (Fallback)", object: "model", variants: {} });
     }
     // 1.5 FORCE ENSURE CRITICAL MODELS
-    // Sometimes the API list changes or is cached weirdly. We force vital models.
-    const hasGemini = modelsOutput.find(m => m.id === 'free/gemini');
-    if (!hasGemini) {
-        log(`[ConfigGen] Force-injecting free/gemini.`);
-        modelsOutput.push({ id: "free/gemini", name: "[Free] Gemini Flash (Force)", object: "model", variants: {} });
-    }
+    // REMOVED: Duplicate Gemini/Flash injection.
+    // The alias below handles standardizing the ID.
     // ALIAS for Full ID matching (Fix ProviderModelNotFoundError) - ALWAYS CHECK SEPARATELY
     const hasGeminiAlias = modelsOutput.find(m => m.id === 'pollinations/free/gemini');
     if (!hasGeminiAlias) {
@@ -88,22 +89,41 @@ export async function generatePollinationsConfig(forceApiKey) {
     // 2. ENTERPRISE UNIVERSE
     if (effectiveKey && effectiveKey.length > 5 && effectiveKey !== 'dummy') {
         try {
-            const enterListRaw = await fetchJson('https://gen.pollinations.ai/text/models', {
+            const enterListRaw = await fetchJson('https://gen.pollinations.ai/models', {
                 'Authorization': `Bearer ${effectiveKey}`
             });
             const enterList = Array.isArray(enterListRaw) ? enterListRaw : (enterListRaw.data || []);
+            const paidModels = [];
             enterList.forEach((m) => {
                 if (m.tools === false)
                     return;
                 const mapped = mapModel(m, 'enter/', '[Enter] ');
                 modelsOutput.push(mapped);
+                if (m.paid_only) {
+                    paidModels.push(mapped.id.replace('enter/', '')); // Store bare ID "gemini-large"
+                }
             });
             log(`Total models (Free+Pro): ${modelsOutput.length}`);
+            // Save Paid Models List for Proxy
+            try {
+                const paidListPath = path.join(config.gui ? path.dirname(CONFIG_FILE) : '/tmp', 'pollinations-paid-models.json');
+                // Ensure dir exists (re-use config dir logic from config.ts if possible, or just assume it exists since config loaded)
+                if (fs.existsSync(path.dirname(paidListPath))) {
+                    fs.writeFileSync(paidListPath, JSON.stringify(paidModels));
+                }
+            }
+            catch (e) {
+                log(`Error saving paid models list: ${e}`);
+            }
         }
         catch (e) {
             log(`Error fetching Enterprise models: ${e}`);
+            // STRICT MODE (Validation): Do not return fake fallback models.
+            if (forceStrict)
+                throw e;
             // Fallback Robust for Enterprise (User has Key but discovery failed)
             modelsOutput.push({ id: "enter/gpt-4o", name: "[Enter] GPT-4o (Fallback)", object: "model", variants: {} });
+            // ...
             modelsOutput.push({ id: "enter/claude-3-5-sonnet", name: "[Enter] Claude 3.5 Sonnet (Fallback)", object: "model", variants: {} });
             modelsOutput.push({ id: "enter/deepseek-reasoner", name: "[Enter] DeepSeek R1 (Fallback)", object: "model", variants: {} });
         }
@@ -123,7 +143,11 @@ function mapModel(raw, prefix, namePrefix) {
     if (baseName && baseName.includes(' - ')) {
         baseName = baseName.split(' - ')[0].trim();
     }
-    const finalName = `${namePrefix}${baseName}`;
+    let namePrefixFinal = namePrefix;
+    if (raw.paid_only) {
+        namePrefixFinal = namePrefix.replace('[Enter]', '[💎 Paid]');
+    }
+    const finalName = `${namePrefixFinal}${baseName}`;
     const modelObj = {
         id: fullId,
         name: finalName,

package/dist/server/proxy.js

@@ -151,14 +151,8 @@ export async function handleChatCompletion(req, res, bodyRaw) {
     try {
         const body = JSON.parse(bodyRaw);
         const config = loadConfig();
-        // --- AGENT DETECTION (v5.5.0 Simplified) ---
-        const systemMsg = body.messages?.find((m) => m.role === 'system')?.content || "";
-        const isSubagent = systemMsg.includes("exploring codebases") ||
-            systemMsg.includes("title generator") ||
-            systemMsg.includes("researching complex questions") ||
-            systemMsg.includes("session summary");
-        const agentLabel = isSubagent ? "Subagent" : "Primary";
-        log(`[Proxy] Agent Detected: ${agentLabel} (Tools: ${body.tools?.length || 0})`);
+        // DEBUG: Trace Config State for Hot Reload verification
+        log(`[Proxy Request] Config Loaded. Mode: ${config.mode}, HasKey: ${!!config.apiKey}, KeyLength: ${config.apiKey ? config.apiKey.length : 0}`);
         // 0. COMMAND HANDLING
         if (body.messages && body.messages.length > 0) {
             const lastMsg = body.messages[body.messages.length - 1];
@@ -226,27 +220,106 @@ export async function handleChatCompletion(req, res, bodyRaw) {
             isEnterprise = false;
             actualModel = actualModel.replace('free/', '');
         }
+        // A.1 PAID MODEL ENFORCEMENT (V5.5 Strategy)
+        // Check dynamic list saved by generate-config.ts
+        if (isEnterprise) {
+            try {
+                const paidListPath = path.join(config.gui ? path.dirname(path.join(process.env.HOME || '/tmp', '.config/opencode/pollinations-signature.json')) : '/tmp', 'pollinations-paid-models.json');
+                // Wait, logic above for config path is messy. Let's use standard path logic:
+                // config.ts uses ~/.pollinations/config.json usually.
+                // generate-config uses path.join(config.gui ? path.dirname(CONFIG_FILE) : '/tmp')
+                // Let's rely on standard ~/.pollinations location if possible, or try both.
+                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)) {
+                        // IT IS A PAID ONLY MODEL.
+                        // STRICT CHECK: Wallet > 0 required. (Not just Tier)
+                        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/', '');
+                            isEnterprise = false;
+                            isFallbackActive = true;
+                            fallbackReason = "Paid Only Model requires purchased credits";
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                log(`[Proxy] Error checking paid models: ${e}`);
+            }
+        }
         // B. SAFETY NETS (The Core V5 Logic)
-        // B. SPECIALIZED TARGETS (Subagents in Enter Universe)
-        if (isEnterprise && isSubagent) {
-            const specialized = config.fallbacks.enter.subagent;
-            if (specialized && specialized !== 'default') {
-                actualModel = specialized.replace('enter/', '').replace('free/', '');
-                if (specialized.startsWith('free/'))
+        if (config.mode === 'alwaysfree') {
+            if (isEnterprise) {
+                // NEW: Paid Only Check for Always Free
+                // If the user asks for a 💎 Paid Only model while in Always Free, we BLOCK it to save wallet
+                // and fallback to free specific message.
+                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.";
+                        }
+                    }
+                }
+                catch (e) { }
+                if (!isFallbackActive && quota.tier === 'error') {
+                    log(`[SafetyNet] AlwaysFree Mode: Quota Check Failed. Switching to Free Fallback.`);
+                    actualModel = config.fallbacks.free.main.replace('free/', '');
                     isEnterprise = false;
-                log(`[Route] Subagent specialized to: ${actualModel}`);
+                    isFallbackActive = true;
+                    fallbackReason = "Quota Unreachable (Safety)";
+                }
+                else {
+                    const tierRatio = quota.tierLimit > 0 ? (quota.tierRemaining / quota.tierLimit) : 0;
+                    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;
+                        isFallbackActive = true;
+                        fallbackReason = `Daily Tier < ${config.thresholds.tier}% (Wallet Protected)`;
+                    }
+                }
             }
         }
-        // C. SAFETY NETS (The Core V5 Logic)
-        if (config.mode === 'alwaysfree' || config.mode === 'pro') {
+        else if (config.mode === 'pro') {
             if (isEnterprise) {
-                if (!quota.canUseEnterprise || quota.tier === 'error') {
-                    const fallbackModel = isSubagent ? config.fallbacks.free.subagent : config.fallbacks.free.primary;
-                    log(`[SafetyNet] ${config.mode.toUpperCase()} Limit reached. Switching to: ${fallbackModel}`);
-                    actualModel = fallbackModel.replace('free/', '');
+                if (quota.tier === 'error') {
+                    log(`[SafetyNet] Pro Mode: Quota Unreachable. Switching to Free Fallback.`);
+                    actualModel = config.fallbacks.free.main.replace('free/', '');
                     isEnterprise = false;
                     isFallbackActive = true;
-                    fallbackReason = `${config.mode.toUpperCase()} Limit Reached`;
+                    fallbackReason = "Quota Unreachable (Safety)";
+                }
+                else {
+                    const tierRatio = quota.tierLimit > 0 ? (quota.tierRemaining / quota.tierLimit) : 0;
+                    // Logic: Fallback if Wallet is Low (< Threshold) AND Tier is Exhausted (< Threshold %)
+                    // Wait, user wants priority to Free Tier.
+                    // If Free Tier is available (Ratio > Threshold), we usage it (don't fallback).
+                    // If Free Tier is exhausted (Ratio <= Threshold), THEN check Wallet.
+                    // If Wallet also Low, THEN Fallback.
+                    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;
+                        isFallbackActive = true;
+                        fallbackReason = `Wallet & Tier Critical`;
+                    }
                 }
             }
         }
@@ -266,7 +339,7 @@ export async function handleChatCompletion(req, res, bodyRaw) {
             targetUrl = 'https://text.pollinations.ai/openai/chat/completions';
             authHeader = undefined;
             log(`Routing to FREE: ${actualModel} ${isFallbackActive ? '(FALLBACK)' : ''}`);
-            emitLogToast('info', `Routing to: FREE UNIVERSE (${actualModel})`, 'Pollinations Routing');
+            // emitLogToast('info', `Routing to: FREE UNIVERSE (${actualModel})`, 'Pollinations Routing'); // Too noisy
         }
         // NOTIFY SWITCH
         if (isFallbackActive) {
@@ -298,7 +371,7 @@ export async function handleChatCompletion(req, res, bodyRaw) {
         // =========================================================
         // LOGIC BLOCK: MODEL SPECIFIC ADAPTATIONS
         // =========================================================
-        if (proxyBody.tools && Array.isArray(proxyBody.tools)) {
+        if (proxyBody.tools && Array.isArray(proxyBody.tools) && proxyBody.tools.length > 0) {
             // B0. KIMI / MOONSHOT SURGICAL FIX (Restored for Debug)
             // Tools are ENABLED. We rely on penalties and strict stops to fight loops.
             if (actualModel.includes("kimi") || actualModel.includes("moonshot")) {
@@ -351,9 +424,14 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                     });
                     // 2. Sanitize & RESTORE GROUNDING CONFIG (Essential for Vertex Auth)
                     if (proxyBody.tools.length > 0) {
-                        // v5.4.1: MUST send tools_config to avoid 401 Unauthorized on Vertex
-                        proxyBody.tools_config = { google_search_retrieval: { disable: true } };
-                        proxyBody.tools = sanitizeToolsForVertex(proxyBody.tools);
+                        if (hasFunctions) {
+                            proxyBody.tools = sanitizeToolsForVertex(proxyBody.tools);
+                            // ONLY for Free/Vertex: Add tools_config to disable search grounding (required for free tier).
+                            // For Enterprise, adding this causes 403 Forbidden on some keys.
+                            if (!isEnterprise) {
+                                proxyBody.tools_config = { google_search_retrieval: { disable: true } };
+                            }
+                        }
                     }
                     else {
                         // 3. If no tools left (or only search was present), DELETE 'tools' entirely
@@ -448,11 +526,12 @@ export async function handleChatCompletion(req, res, bodyRaw) {
             // 2. Gemini Tools Fix (Gemini + Tools -> 401 -> Fallback to OpenAI)
             const isEnterpriseFallback = (fetchRes.status === 402 || fetchRes.status === 429 || fetchRes.status === 401 || fetchRes.status === 403) && isEnterprise;
             const isGeminiToolsFallback = fetchRes.status === 401 && actualModel.includes('gemini') && !isEnterprise && proxyBody.tools && proxyBody.tools.length > 0;
-            if (isEnterpriseFallback || isGeminiToolsFallback) {
+            // STRICT MANUAL MODE: Disable "Magic" Fallbacks
+            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.primary.replace('free/', '');
+                    actualModel = config.fallbacks.free.main.replace('free/', '');
                     isEnterprise = false;
                     isFallbackActive = true;
                     if (fetchRes.status === 402)
@@ -595,8 +674,9 @@ export async function handleChatCompletion(req, res, bodyRaw) {
             if (isFallbackActive)
                 modeLabel += " (FALLBACK)";
             const fullMsg = `${dashboardMsg} | ⚙️ ${modeLabel}`;
-            // Only emit if not silenced AND only for Enterprise/Paid requests
-            if (isEnterprise) {
+            // Only emit if not silenced AND (only for Enterprise/Paid requests OR if Fallback occurred)
+            // We want to know if our Pro request failed.
+            if (isEnterprise || isFallbackActive) {
                 emitStatusToast('info', fullMsg, 'Pollinations Status');
             }
         }

package/dist/server/quota.d.ts

@@ -10,6 +10,7 @@ export interface QuotaStatus {
     needsAlert: boolean;
     tier: string;
     tierEmoji: string;
+    isLimitedKey?: boolean;
 }
 export declare function getQuotaStatus(forceRefresh?: boolean): Promise<QuotaStatus>;
 export declare function formatQuotaForToast(quota: QuotaStatus): string;

package/dist/server/quota.js

@@ -38,6 +38,25 @@ export async function getQuotaStatus(forceRefresh = false) {
             tierEmoji: '❌'
         };
     }
+    // CHECK LIMITED KEY (v5.5)
+    // If commands.ts detected this key has no profile access, return specific status immediately.
+    // We do NOT attempt to fetch quota to avoid 403 spam.
+    if (config.keyHasAccessToProfile === false) {
+        return {
+            tierRemaining: 0,
+            tierUsed: 0,
+            tierLimit: 0,
+            walletBalance: 0,
+            nextResetAt: new Date(),
+            timeUntilReset: 0,
+            canUseEnterprise: true, // GENERATION IS ALLOWED
+            isUsingWallet: false,
+            needsAlert: false,
+            tier: 'limited',
+            tierEmoji: '🗝️',
+            isLimitedKey: true
+        };
+    }
     const now = Date.now();
     if (!forceRefresh && cachedQuota && (now - lastQuotaFetch) < CACHE_TTL) {
         return cachedQuota;
@@ -66,12 +85,6 @@ export async function getQuotaStatus(forceRefresh = false) {
         // 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)));
-        // Calculer les marges de sécurité basées sur les seuils configurés
-        const tierThresholdPollen = (config.thresholds.tier / 100) * tierLimit;
-        const walletThresholdUSD = config.thresholds.wallet; // Wallet threshold is already in $ in config
-        // canUseEnterprise: Vrai si on a encore du budget au-dessus du seuil de fallback
-        const hasAvailableTier = cleanTierRemaining > tierThresholdPollen;
-        const hasAvailableWallet = cleanWalletBalance > walletThresholdUSD;
         cachedQuota = {
             tierRemaining: cleanTierRemaining,
             tierUsed,
@@ -79,9 +92,9 @@ export async function getQuotaStatus(forceRefresh = false) {
             walletBalance: cleanWalletBalance,
             nextResetAt: resetInfo.nextReset,
             timeUntilReset: resetInfo.timeUntilReset,
-            canUseEnterprise: hasAvailableTier || hasAvailableWallet,
-            isUsingWallet: !hasAvailableTier && hasAvailableWallet,
-            needsAlert: tierLimit > 0 ? (cleanTierRemaining <= tierThresholdPollen) : false,
+            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
         };
@@ -204,6 +217,9 @@ function calculateCurrentPeriodUsage(usage, resetInfo) {
 }
 // === EXPORT POUR LES ALERTES ===
 export function formatQuotaForToast(quota) {
+    if (quota.isLimitedKey) {
+        return "⚠️ Dashboard Limitation: Clé restreinte (Activez Profile/Usage/Balance pour voir le Quota)";
+    }
     const tierPercent = quota.tierLimit > 0
         ? Math.round((quota.tierRemaining / quota.tierLimit) * 100)
         : 0;

package/package.json

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