opencode-pollinations-plugin 6.0.0-beta.24 → 6.0.0-beta.3

package/README.md

@@ -1,4 +1,4 @@
-# 🌸 Pollinations AI Plugin for OpenCode (v5.6.0)
+# 🌸 Pollinations AI Plugin for OpenCode (v5.9.0)
 
 <div align="center">
   <img src="https://avatars.githubusercontent.com/u/88394740?s=400&v=4" alt="Pollinations.ai Logo" width="200">
@@ -10,11 +10,9 @@
 
 <div align="center">
 
-![Version](https://img.shields.io/badge/version-5.8.4--beta.15-orange.svg)
+![Version](https://img.shields.io/badge/version-5.6.0-blue.svg)
 ![License](https://img.shields.io/badge/license-MIT-green.svg)
-![Status](https://img.shields.io/badge/status-Beta-yellow.svg)
-
-[📜 View Changelog](./CHANGELOG.md) | [🛣️ Roadmap](./ROADMAP.md)
+![Status](https://img.shields.io/badge/status-Stable-success.svg)
 
 </div>
 
@@ -136,8 +134,9 @@ OpenCode uses NPM as its registry. To publish:
 
 ### 1. The Basics (Free Mode)
 Just type in the chat. You are in **Manual Mode** by default.
-- Model: `openai` (GPT-4o Mini equivalent)
-- Model: `mistral` (Mistral Nemo)
+- Model: `openai-fast` (GPT-OSS 20b)
+- Model: `mistral` (Mistral Small 3.1)
+- ...
 
 ### 🔑 Configuration (API Key)
 
@@ -157,6 +156,7 @@ Just type in the chat. You are in **Manual Mode** by default.
 
 ## 🔗 Links
 
+- **Sign up Pollinations Beta (more and best free tiers access and paids models)**: [pollinations.ai](https://enter.pollinations.ai)
 - **Pollinations Website**: [pollinations.ai](https://pollinations.ai)
 - **Discord Community**: [Join us!](https://discord.gg/pollinations-ai-885844321461485618)
 - **OpenCode Ecosystem**: [opencode.ai](https://opencode.ai/docs/ecosystem#plugins)

package/dist/index.js

@@ -1,11 +1,12 @@
 import * as http from 'http';
 import * as fs from 'fs';
 import { generatePollinationsConfig } from './server/generate-config.js';
-import { loadConfig, saveConfig } from './server/config.js';
+import { loadConfig } from './server/config.js';
 import { handleChatCompletion } from './server/proxy.js';
 import { createToastHooks, setGlobalClient } from './server/toast.js';
 import { createStatusHooks } from './server/status.js';
 import { createCommandHooks } from './server/commands.js';
+import { createToolRegistry } from './tools/index.js';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const LOG_FILE = '/tmp/opencode_pollinations_v4.log';
@@ -15,17 +16,12 @@ function log(msg) {
     }
     catch (e) { }
 }
-// === PROXY SERVER (Singleton with Fixed Port) ===
-const DEFAULT_PORT = 18888;
-const GLOBAL_SERVER_KEY = '__POLLINATIONS_PROXY_SERVER__';
+// Port killing removed: Using dynamic ports.
 const startProxy = () => {
-    // Check if server exists in global scope (survives module reloads)
-    if (global[GLOBAL_SERVER_KEY]) {
-        log(`[Proxy] Reusing existing global server on port ${DEFAULT_PORT}`);
-        return Promise.resolve(DEFAULT_PORT);
-    }
     return new Promise((resolve) => {
         const server = http.createServer(async (req, res) => {
+            // ... (Request Handling) ...
+            // We reuse the existing logic structure but simplified startup
             log(`[Proxy] Request: ${req.method} ${req.url}`);
             res.setHeader('Access-Control-Allow-Origin', '*');
             res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
@@ -67,188 +63,37 @@ const startProxy = () => {
             res.writeHead(404);
             res.end("Not Found");
         });
-        // Try fixed port first, fallback to dynamic if occupied
-        const tryListen = (port, fallbackToDynamic) => {
-            server.listen(port, '127.0.0.1', () => {
-                // @ts-ignore
-                const assignedPort = server.address().port;
-                global[GLOBAL_SERVER_KEY] = server;
-                log(`[Proxy] Started v${require('../package.json').version} on port ${assignedPort}${port === 0 ? ' (dynamic fallback)' : ''}`);
-                resolve(assignedPort);
-            });
-            server.on('error', (e) => {
-                if (e.code === 'EADDRINUSE' && fallbackToDynamic) {
-                    log(`[Proxy] Port ${port} in use, falling back to dynamic port`);
-                    server.removeAllListeners('error');
-                    tryListen(0, false); // Try dynamic port
-                }
-                else {
-                    log(`[Proxy] Fatal Error: ${e}`);
-                    resolve(0);
-                }
-            });
-        };
-        tryListen(DEFAULT_PORT, true);
+        // Listen on random port (0) to avoid conflicts (CLI/IDE)
+        server.listen(0, '127.0.0.1', () => {
+            // @ts-ignore
+            const assignedPort = server.address().port;
+            log(`[Proxy] Started v${require('../package.json').version} (Dynamic Port) on port ${assignedPort}`);
+            resolve(assignedPort);
+        });
+        server.on('error', (e) => {
+            log(`[Proxy] Fatal Error: ${e}`);
+            resolve(0);
+        });
     });
 };
-// === AUTH HOOK: Native /connect Integration ===
-const createAuthHook = () => ({
-    provider: 'pollinations',
-    // LOADER: Called by OpenCode when it needs credentials
-    // This enables HOT RELOAD - called before each request that needs auth
-    loader: async (auth, provider) => {
-        log('[AuthHook] loader() called - fetching credentials');
-        try {
-            const authData = await auth();
-            if (authData && 'key' in authData && authData.key) {
-                log(`[AuthHook] Got key from OpenCode auth: ${authData.key.substring(0, 8)}...`);
-                // Sync to our config for other parts of the plugin
-                saveConfig({ apiKey: authData.key });
-                return { apiKey: authData.key };
-            }
-        }
-        catch (e) {
-            log(`[AuthHook] loader() error: ${e}`);
-        }
-        // Fallback to our own config
-        const config = loadConfig();
-        if (config.apiKey) {
-            log(`[AuthHook] Using key from plugin config: ${config.apiKey.substring(0, 8)}...`);
-            return { apiKey: config.apiKey };
-        }
-        log('[AuthHook] No API key available');
-        return {};
-    },
-    // METHODS: Define how user can authenticate
-    methods: [{
-            type: 'api',
-            label: 'API Key',
-            prompts: [{
-                    type: 'text',
-                    key: 'apiKey',
-                    message: 'Enter your Pollinations API Key',
-                    placeholder: 'sk_...',
-                    validate: (value) => {
-                        if (!value || value.length < 10) {
-                            return 'API key must be at least 10 characters';
-                        }
-                        if (!value.startsWith('sk_') && !value.startsWith('sk-')) {
-                            return 'API key should start with sk_ or sk-';
-                        }
-                        return undefined; // Valid
-                    }
-                }],
-            authorize: async (inputs) => {
-                log(`[AuthHook] authorize() called with key: ${inputs?.apiKey?.substring(0, 8)}...`);
-                if (!inputs?.apiKey) {
-                    return { type: 'failed' };
-                }
-                // Validate key by testing API
-                try {
-                    const response = await fetch('https://gen.pollinations.ai/text/models', {
-                        headers: { 'Authorization': `Bearer ${inputs.apiKey}` }
-                    });
-                    if (response.ok) {
-                        log('[AuthHook] Key validated successfully');
-                        // Save to our config for immediate use
-                        saveConfig({ apiKey: inputs.apiKey });
-                        return { type: 'success', key: inputs.apiKey };
-                    }
-                    else {
-                        log(`[AuthHook] Key validation failed: ${response.status}`);
-                        return { type: 'failed' };
-                    }
-                }
-                catch (e) {
-                    log(`[AuthHook] Key validation error: ${e}`);
-                    return { type: 'failed' };
-                }
-            }
-        }]
-});
 // === PLUGIN EXPORT ===
 export const PollinationsPlugin = async (ctx) => {
     log(`Plugin Initializing v${require('../package.json').version}...`);
-    // START PROXY on fixed port
+    // START PROXY
     const port = await startProxy();
     const localBaseUrl = `http://127.0.0.1:${port}/v1`;
     setGlobalClient(ctx.client);
     const toastHooks = createToastHooks(ctx.client);
     const commandHooks = createCommandHooks();
-    // Helper: Refresh provider config (for hot-reload after /connect)
-    let isRefreshing = false;
-    const refreshProviderConfig = async () => {
-        if (isRefreshing)
-            return;
-        isRefreshing = true;
-        try {
-            log('[Event] Refreshing provider config after auth update...');
-            const modelsArray = await generatePollinationsConfig();
-            const modelsObj = {};
-            for (const m of modelsArray) {
-                modelsObj[m.id] = m;
-            }
-            const version = require('../package.json').version;
-            // CRITICAL: Fetch current config first to avoid overwriting other providers
-            let currentConfig = {};
-            try {
-                // Try to fetch existing config to preserve other providers
-                const response = await ctx.client.fetch('/config');
-                if (response.ok) {
-                    currentConfig = await response.json();
-                }
-            }
-            catch (err) {
-                log(`[Event] Warning: Could not fetch current config: ${err}`);
-            }
-            // Safe Merge
-            if (!currentConfig.provider)
-                currentConfig.provider = {};
-            currentConfig.provider.pollinations = {
-                id: 'openai',
-                name: `Pollinations AI (v${version})`,
-                options: {
-                    baseURL: localBaseUrl,
-                    apiKey: 'plugin-managed',
-                },
-                models: modelsObj
-            };
-            // Use Server API to update config with the MERGED object
-            await ctx.client.fetch('/config', {
-                method: 'PATCH',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    provider: currentConfig.provider
-                })
-            });
-            log(`[Event] Provider config refreshed with ${Object.keys(modelsObj).length} models.`);
-        }
-        catch (e) {
-            log(`[Event] Failed to refresh provider config: ${e}`);
-        }
-        finally {
-            // Debounce: prevent another refresh for 5 seconds
-            setTimeout(() => { isRefreshing = false; }, 5000);
-        }
-    };
+    // Build tool registry (conditional on API key presence)
+    const toolRegistry = createToolRegistry();
+    log(`[Tools] ${Object.keys(toolRegistry).length} tools registered`);
     return {
-        // AUTH HOOK: Native /connect integration
-        auth: createAuthHook(),
-        // EVENT HOOK: Listen ONLY for explicit /connect command
-        // We removed installation.updated/server.connected because they caused infinite loops
-        event: async ({ event }) => {
-            if (event.type === 'tui.command.execute') {
-                const cmd = event.command || event.data?.command;
-                if (cmd === 'connect' || cmd === '/connect') {
-                    log('[Event] /connect command detected - will refresh after auth hook completes');
-                    // Small delay to let auth hook complete
-                    setTimeout(() => refreshProviderConfig(), 2000);
-                }
-            }
-        },
+        tool: toolRegistry,
         async config(config) {
             log("[Hook] config() called");
-            // Generate models based on current auth state
+            // STARTUP only - No complex hot reload logic
+            // The user must restart OpenCode to refresh this list if they change keys.
             const modelsArray = await generatePollinationsConfig();
             const modelsObj = {};
             for (const m of modelsArray) {
@@ -256,14 +101,12 @@ export const PollinationsPlugin = async (ctx) => {
             }
             if (!config.provider)
                 config.provider = {};
+            // Dynamic Provider Name
             const version = require('../package.json').version;
             config.provider['pollinations'] = {
-                id: 'openai',
+                id: 'pollinations',
                 name: `Pollinations AI (v${version})`,
-                options: {
-                    baseURL: localBaseUrl,
-                    apiKey: 'plugin-managed', // Key is managed by auth hook
-                },
+                options: { baseURL: localBaseUrl },
                 models: modelsObj
             };
             log(`[Hook] Registered ${Object.keys(modelsObj).length} models.`);

package/dist/server/commands.js

@@ -303,15 +303,15 @@ async function handleConnectCommand(args) {
     // 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 real models (not just connect placeholder)
-        const realModels = models.filter(m => m.id !== 'connect');
-        if (realModels.length > 0) {
+        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 = realModels.filter(m => m.name.includes('💎')).length;
+            const diamondCount = enterpriseModels.filter(m => m.name.includes('💎')).length;
             // CHECK RESTRICTIONS: Strict Check (Usage + Profile + Balance)
             let forcedModeMsg = "";
             let isLimited = false;
@@ -336,10 +336,10 @@ async function handleConnectCommand(args) {
             else {
                 saveConfig({ apiKey: key, keyHasAccessToProfile: true }); // Let user keep current mode or default
             }
-            emitStatusToast('success', `Clé Valide! (${realModels.length} modèles débloqués)`, 'Pollinations Config');
+            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: ${realModels.length} (dont ${diamondCount} 💎 Paid)${forcedModeMsg}`
+                response: `✅ **Connexion Réussie!**\n- Clé: \`${masked}\`\n- Modèles Débloqués: ${enterpriseModels.length} (dont ${diamondCount} 💎 Paid)${forcedModeMsg}`
             };
         }
         else {
@@ -351,8 +351,18 @@ async function handleConnectCommand(args) {
             // 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.
-            // v6.0: No fallback prefix check needed. If models is empty (only connect), key is invalid.
-            throw new Error("Aucun modèle détecté pour cette clé. Clé invalide ou expirée.");
+            // 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) {

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

@@ -1,34 +1,8 @@
-/**
- * generate-config.ts - v6.0 Simplified
- *
- * Single endpoint: gen.pollinations.ai/text/models
- * No more Free tier, no cache ETag, no prefixes
- */
-export interface PollinationsModel {
-    name: string;
-    description?: string;
-    type?: string;
-    tools?: boolean;
-    reasoning?: boolean;
-    context?: number;
-    context_window?: number;
-    input_modalities?: string[];
-    output_modalities?: string[];
-    paid_only?: boolean;
-    vision?: boolean;
-    audio?: boolean;
-    pricing?: {
-        promptTextTokens?: number;
-        completionTextTokens?: number;
-        promptImageTokens?: number;
-        promptAudioTokens?: number;
-        completionAudioTokens?: number;
-    };
-    [key: string]: any;
-}
 interface OpenCodeModel {
     id: string;
     name: string;
+    object: string;
+    variants?: any;
     options?: any;
     limit?: {
         context?: number;
@@ -38,7 +12,6 @@ interface OpenCodeModel {
         input?: string[];
         output?: string[];
     };
-    tool_call?: boolean;
 }
-export declare function generatePollinationsConfig(forceApiKey?: string): Promise<OpenCodeModel[]>;
+export declare function generatePollinationsConfig(forceApiKey?: string, forceStrict?: boolean): Promise<OpenCodeModel[]>;
 export {};