opencode-pollinations-plugin 5.4.8 → 5.4.10

package/dist/server/commands.js

@@ -2,6 +2,7 @@ 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';
 // === CONSTANTS & PRICING ===
 const TIER_LIMITS = {
     spore: { pollen: 1, emoji: '🦠' },
@@ -204,28 +205,64 @@ function handleFallbackCommand(args) {
         response: `✅ Fallback (Free) configuré: main=${main}, agent=${agent || config.fallbacks.free.agent}`
     };
 }
-function handleConnectCommand(args) {
+async function handleConnectCommand(args) {
     const key = args[0];
     if (!key) {
         return {
             handled: true,
-            error: `Utilisation: /pollinations connect <sk-xxxx>`
+            error: `Utilisation: /pollinations connect <votre_clé_api>`
         };
     }
-    if (!key.startsWith('sk-')) {
+    // 1. Universal Validation (No Syntax Check) - Functional Check
+    emitStatusToast('info', 'Vérification de la clé...', 'Pollinations Config');
+    try {
+        const models = await generatePollinationsConfig(key);
+        // 2. Check if we got Enterprise models
+        const enterpriseModels = models.filter(m => m.id.startsWith('enter/'));
+        if (enterpriseModels.length > 0) {
+            // SUCCESS
+            saveConfig({ apiKey: key, mode: 'pro' });
+            const masked = key.substring(0, 6) + '...';
+            // Count Paid Only models found
+            const diamondCount = enterpriseModels.filter(m => m.name.includes('💎')).length;
+            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- Mode: **PRO** (Activé)\n- Modèles Débloqués: ${enterpriseModels.length} (dont ${diamondCount} 💎 Paid)`
+            };
+        }
+        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: `Clé invalide. Elle doit commencer par 'sk-'.`
+            error: `❌ **Échec Connexion**: ${e.message || e}\n\nLa configuration a été réinitialisée (Mode Gratuit/Manuel).`
         };
     }
-    // Save API Key only (User decides mode manually)
-    saveConfig({ apiKey: key });
-    // Confirm
-    emitStatusToast('success', 'API Key enregistrée', 'Pollinations Config');
-    return {
-        handled: true,
-        response: `✅ API Key connectée. (Utilisez /pollinations mode pro pour l'activer)`
-    };
 }
 function handleConfigCommand(args) {
     const [key, value] = args;

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) {
@@ -92,18 +97,34 @@ export async function generatePollinationsConfig(forceApiKey) {
                 '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}`);
             // 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 +144,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

@@ -220,6 +220,43 @@ 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)
         if (config.mode === 'alwaysfree') {
             if (isEnterprise) {

package/package.json

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