opencode-pollinations-plugin 5.8.2 → 5.8.4-beta.1

package/dist/server/generate-config.js

@@ -5,7 +5,17 @@ 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');
+const CACHE_FILE = path.join(CONFIG_DIR_POLLI, 'models-cache.json');
+// --- CONSTANTS ---
+// Seed from _archs/debug_free.json
+const DEFAULT_FREE_MODELS = [
+    { "name": "gemini", "description": "Gemini 2.5 Flash Lite", "tier": "anonymous", "tools": true, "input_modalities": ["text", "image"], "output_modalities": ["text"], "vision": true },
+    { "name": "mistral", "description": "Mistral Small 3.2 24B", "tier": "anonymous", "tools": true, "input_modalities": ["text"], "output_modalities": ["text"], "vision": false },
+    { "name": "openai-fast", "description": "GPT-OSS 20B Reasoning LLM (OVH)", "tier": "anonymous", "tools": true, "input_modalities": ["text"], "output_modalities": ["text"], "vision": false, "reasoning": true },
+    { "name": "bidara", "description": "BIDARA (Biomimetic Designer)", "tier": "anonymous", "community": true, "input_modalities": ["text", "image"], "output_modalities": ["text"], "vision": true },
+    { "name": "chickytutor", "description": "ChickyTutor AI Language Tutor", "tier": "anonymous", "community": true, "input_modalities": ["text"], "output_modalities": ["text"] },
+    { "name": "midijourney", "description": "MIDIjourney", "tier": "anonymous", "community": true, "input_modalities": ["text"], "output_modalities": ["text"] }
+];
 // --- LOGGING ---
 const LOG_FILE = '/tmp/opencode_pollinations_config.log';
 function log(msg) {
@@ -16,27 +26,41 @@ function log(msg) {
         fs.appendFileSync(LOG_FILE, `[ConfigGen] ${ts} ${msg}\n`);
     }
     catch (e) { }
-    // Force output to stderr for CLI visibility if needed, but clean.
 }
-// Fetch Helper
-// Fetch Helper
+// --- NETWORK HELPER ---
+function fetchHead(url) {
+    return new Promise((resolve) => {
+        // Use Node.js native https check for minimal overhead
+        const req = https.request(url, { method: 'HEAD', timeout: 5000 }, (res) => {
+            resolve(res.headers['etag'] || null);
+        });
+        req.on('error', () => resolve(null));
+        req.on('timeout', () => { req.destroy(); resolve(null); });
+        req.end();
+    });
+}
 function fetchJson(url, headers = {}) {
     return new Promise((resolve, reject) => {
         const finalHeaders = {
             ...headers,
-            'User-Agent': 'Mozilla/5.0 (compatible; OpenCode/5.8.1; +https://opencode.ai)'
+            'User-Agent': 'Mozilla/5.0 (compatible; OpenCode/5.8.4; +https://opencode.ai)'
         };
         const req = https.get(url, { headers: finalHeaders }, (res) => {
+            const etag = res.headers['etag'];
             let data = '';
             res.on('data', chunk => data += chunk);
             res.on('end', () => {
                 try {
                     const json = JSON.parse(data);
+                    // HACK: Attach ETag to the object to pass it up
+                    if (etag && typeof json === 'object') {
+                        Object.defineProperty(json, '_etag', { value: etag, enumerable: false, writable: true });
+                    }
                     resolve(json);
                 }
                 catch (e) {
                     log(`JSON Parse Error for ${url}: ${e}`);
-                    resolve([]); // Fail safe -> empty list
+                    resolve([]); // Fail safe
                 }
             });
         });
@@ -50,167 +74,160 @@ function fetchJson(url, headers = {}) {
         });
     });
 }
-function formatName(id, censored = true) {
-    let clean = id.replace(/^pollinations\//, '').replace(/-/g, ' ');
-    clean = clean.replace(/\b\w/g, l => l.toUpperCase());
-    if (!censored)
-        clean += " (Uncensored)";
-    return clean;
+function loadCache() {
+    try {
+        if (fs.existsSync(CACHE_FILE)) {
+            const content = fs.readFileSync(CACHE_FILE, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch (e) {
+        log(`Error loading cache: ${e}`);
+    }
+    return null;
 }
-// --- MAIN GENERATOR logic ---
+function saveCache(models, etag) {
+    try {
+        const data = {
+            timestamp: Date.now(),
+            etag: etag,
+            models: models
+        };
+        if (!fs.existsSync(CONFIG_DIR_POLLI))
+            fs.mkdirSync(CONFIG_DIR_POLLI, { recursive: true });
+        fs.writeFileSync(CACHE_FILE, JSON.stringify(data, null, 2));
+    }
+    catch (e) {
+        log(`Error saving cache: ${e}`);
+    }
+}
+// --- GENERATOR LOGIC ---
 export async function generatePollinationsConfig(forceApiKey, forceStrict = false) {
     const config = loadConfig();
     const modelsOutput = [];
-    log(`Starting Configuration (v5.8.2)...`);
-    // Use forced key (from Hook) or cached key
+    log(`Starting Configuration (v5.8.4-Beta1)...`);
     const effectiveKey = forceApiKey || config.apiKey;
-    // 1. FREE UNIVERSE
-    try {
-        // Switch to main models endpoint
-        const freeList = await fetchJson('https://text.pollinations.ai/models');
-        const list = Array.isArray(freeList) ? freeList : (freeList.data || []);
-        if (list.length > 0) {
-            list.forEach((m) => {
-                const mapped = mapModel(m, 'free/', '[Free] ');
-                modelsOutput.push(mapped);
-            });
-            log(`Fetched ${modelsOutput.length} Free models.`);
+    // 1. FREE UNIVERSE (Smart Cache System)
+    let freeModelsList = [];
+    let isOffline = false;
+    let cache = loadCache();
+    const CACHE_TTL = 7 * 24 * 3600 * 1000; // 7 days
+    // Decision Logic
+    const now = Date.now();
+    let shouldFetch = !cache || (now - cache.timestamp > CACHE_TTL);
+    // ETag Check: If cache is valid but we want to be proactive
+    if (!shouldFetch && cache && cache.etag) {
+        try {
+            log('Smart Refresh: Checking for updates (HEAD)...');
+            const remoteEtag = await fetchHead('https://text.pollinations.ai/models');
+            if (remoteEtag && remoteEtag !== cache.etag) {
+                log(`Update Detected! (Remote: ${remoteEtag} != Local: ${cache.etag}). Forcing refresh.`);
+                shouldFetch = true;
+            }
+            else {
+                log('Cache is clean (ETag match). No refresh needed.');
+            }
         }
-        else {
-            throw new Error('Empty list returned from Free API');
+        catch (e) {
+            log(`Smart Refresh check failed: ${e}. Ignoring.`);
         }
     }
-    catch (e) {
-        log(`Error fetching Free models: ${e}`);
-        // Fallback Robust (Offline support) - NOW WITH ICONS
-        modelsOutput.push({
-            id: "free/mistral",
-            name: "[Free] Mistral Nemo (Fallback) 💻",
-            object: "model",
-            variants: { safe_tokens: { options: { maxTokens: 8000 } } },
-            modalities: { input: ['text'], output: ['text'] }
-        });
-        modelsOutput.push({
-            id: "free/openai",
-            name: "[Free] OpenAI (Fallback) 👁️💻",
-            object: "model",
-            variants: {},
-            modalities: { input: ['text', 'image'], output: ['text'] }
-        });
-        modelsOutput.push({
-            id: "free/gemini",
-            name: "[Free] Gemini Flash (Fallback) 👁️💻",
-            object: "model",
-            variants: { high_reasoning: { options: { reasoningEffort: "high", budgetTokens: 16000 } } },
-            modalities: { input: ['text', 'image'], output: ['text'] }
-        });
-        modelsOutput.push({
-            id: "free/searchgpt",
-            name: "[Free] SearchGPT (Fallback) 🔍",
-            object: "model",
-            variants: {},
-            modalities: { input: ['text'], output: ['text'] }
-        });
+    if (shouldFetch) {
+        log('Fetching fresh Free models...');
+        try {
+            const raw = await fetchJson('https://text.pollinations.ai/models');
+            const list = Array.isArray(raw) ? raw : (raw.data || []);
+            const newEtag = raw._etag; // Get hidden ETag
+            if (list.length > 0) {
+                freeModelsList = list;
+                saveCache(list, newEtag);
+                log(`Fetched and cached ${list.length} models (ETag: ${newEtag || 'N/A'}).`);
+            }
+            else {
+                throw new Error('API returned empty list');
+            }
+        }
+        catch (e) {
+            log(`Fetch failed: ${e}.`);
+            isOffline = true;
+            // Fallback Logic
+            if (cache && cache.models.length > 0) {
+                log('Using cached models (Offline).');
+                freeModelsList = cache.models;
+            }
+            else {
+                log('Using DEFAULT SEED models (Offline + No Cache).');
+                freeModelsList = DEFAULT_FREE_MODELS;
+            }
+        }
     }
-    // 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: {},
-            modalities: { input: ['text', 'image'], output: ['text'] }
-        });
+    else {
+        log('Using cached models (Skipped fetch).');
+        freeModelsList = cache.models;
     }
-    // ALIAS Removed for Clean Config
-    // const hasGeminiAlias = modelsOutput.find(m => m.id === 'pollinations/free/gemini');
-    // if (!hasGeminiAlias) {
-    //    modelsOutput.push({ id: "pollinations/free/gemini", name: "[Free] Gemini Flash (Alias)", object: "model", variants: {} });
-    // }
+    // Map Free Models
+    freeModelsList.forEach((m) => {
+        // Tag (Offline) only if we explicitly failed a fetch attempt or are using Fallback SEED when fetch failed.
+        // If we use cache because it's valid (Skipped fetch), we don't tag (Offline).
+        const suffix = isOffline ? ' (Offline)' : '';
+        const mapped = mapModel(m, 'free/', `[Free] `, suffix);
+        modelsOutput.push(mapped);
+    });
     // 2. ENTERPRISE UNIVERSE
     if (effectiveKey && effectiveKey.length > 5 && effectiveKey !== 'dummy') {
         try {
-            // Use /text/models for full metadata (input_modalities, tools, reasoning, pricing)
             const enterListRaw = await fetchJson('https://gen.pollinations.ai/text/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: {} });
         }
     }
     return modelsOutput;
 }
-// --- CAPABILITY ICONS ---
+// --- UTILS ---
 function getCapabilityIcons(raw) {
     const icons = [];
-    // Vision: accepts images
-    if (raw.input_modalities?.includes('image'))
+    if (raw.input_modalities?.includes('image') || raw.vision === true)
         icons.push('👁️');
-    // Audio Input
-    if (raw.input_modalities?.includes('audio'))
+    if (raw.input_modalities?.includes('audio') || raw.audio === true)
         icons.push('🎙️');
-    // Audio Output
     if (raw.output_modalities?.includes('audio'))
         icons.push('🔊');
-    // Reasoning capability
     if (raw.reasoning === true)
         icons.push('🧠');
-    // Web Search (from description)
-    if (raw.description?.toLowerCase().includes('search') ||
-        raw.name?.includes('search') ||
-        raw.name?.includes('perplexity')) {
+    if (raw.description?.toLowerCase().includes('search') || raw.name?.includes('search'))
         icons.push('🔍');
-    }
-    // Tool/Function calling
     if (raw.tools === true)
         icons.push('💻');
     return icons.length > 0 ? ` ${icons.join('')}` : '';
 }
-// --- MAPPING ENGINE ---
-function mapModel(raw, prefix, namePrefix) {
+function formatName(id, censored = true) {
+    let clean = id.replace(/^pollinations\//, '').replace(/-/g, ' ');
+    clean = clean.replace(/\b\w/g, l => l.toUpperCase());
+    if (!censored)
+        clean += " (Uncensored)";
+    return clean;
+}
+function mapModel(raw, prefix, namePrefix, nameSuffix = '') {
     const rawId = raw.id || raw.name;
-    const fullId = prefix + rawId; // ex: "free/gemini" or "enter/nomnom" (prefix passed is "enter/")
+    const fullId = prefix + rawId;
     let baseName = raw.description;
     if (!baseName || baseName === rawId) {
         baseName = formatName(rawId, raw.censored !== false);
     }
-    // CLEANUP: Simple Truncation Rule (Requested by User)
-    // "Start from left, find ' - ', delete everything after."
     if (baseName && baseName.includes(' - ')) {
         baseName = baseName.split(' - ')[0].trim();
     }
@@ -218,16 +235,19 @@ function mapModel(raw, prefix, namePrefix) {
     if (raw.paid_only) {
         namePrefixFinal = namePrefix.replace('[Enter]', '[💎 Paid]');
     }
-    // Get capability icons from API metadata
     const capabilityIcons = getCapabilityIcons(raw);
-    const finalName = `${namePrefixFinal}${baseName}${capabilityIcons}`;
+    const finalName = `${namePrefixFinal}${baseName}${nameSuffix}${capabilityIcons}`;
     const modelObj = {
         id: fullId,
         name: finalName,
         object: 'model',
-        variants: {}
+        variants: {},
+        modalities: {
+            input: raw.input_modalities || ['text'],
+            output: raw.output_modalities || ['text']
+        }
     };
-    // --- ENRICHISSEMENT ---
+    // Enrichissements
     if (raw.reasoning === true || rawId.includes('thinking') || rawId.includes('reasoning')) {
         modelObj.variants = { ...modelObj.variants, high_reasoning: { options: { reasoningEffort: "high", budgetTokens: 16000 } } };
     }
@@ -239,25 +259,13 @@ function mapModel(raw, prefix, namePrefix) {
     if (rawId.includes('claude') || rawId.includes('mistral') || rawId.includes('llama')) {
         modelObj.variants.safe_tokens = { options: { maxTokens: 8000 } };
     }
-    // NOVA FIX: Bedrock limit ~10k (User reported error > 10000)
-    // We MUST set the limit on the model object itself so OpenCode respects it by default.
     if (rawId.includes('nova')) {
-        modelObj.limit = {
-            output: 8000,
-            context: 128000 // Nova Micro/Lite/Pro usually 128k
-        };
-        // Also keep variant just in case
-        modelObj.variants.bedrock_safe = { options: { maxTokens: 8000 } };
+        modelObj.limit = { output: 8000, context: 128000 };
     }
-    // NOMNOM FIX: User reported error if max_tokens is missing.
-    // Also it is a 'Gemini-scrape' model, so we treat it similar to Gemini but with strict limit.
     if (rawId.includes('nomnom') || rawId.includes('scrape')) {
-        modelObj.limit = {
-            output: 2048, // User used 1500 successfully
-            context: 32768
-        };
+        modelObj.limit = { output: 2048, context: 32768 };
     }
-    if (rawId.includes('fast') || rawId.includes('flash') || rawId.includes('lite')) {
+    if (rawId.includes('fast') || rawId.includes('flash')) {
         if (!rawId.includes('gemini')) {
             modelObj.variants.speed = { options: { thinking: { disabled: true } } };
         }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "opencode-pollinations-plugin",
     "displayName": "Pollinations AI (V5.6)",
-    "version": "5.8.2",
+    "version": "5.8.4-beta.1",
     "description": "Native Pollinations.ai Provider Plugin for OpenCode",
     "publisher": "pollinations",
     "repository": {
@@ -55,4 +55,4 @@
         "@types/node": "^20.0.0",
         "typescript": "^5.0.0"
     }
-}
+}