opencode-pollinations-plugin 6.0.0-beta.25 → 6.0.0-beta.5

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 { createToastHooks, createToolHooks, setGlobalClient } from './server/toast.js';
 import { createStatusHooks } from './server/status.js';
-import { createCommandHooks } from './server/commands.js';
+import { createCommandHooks, setClientForCommands } 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,156 +63,38 @@ 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 ===
-// Auth Hook moved inside plugin to access context
 // === 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);
+    setClientForCommands(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 (INLINED)
-        auth: {
-            provider: 'pollinations',
-            loader: async (auth, provider) => {
-                log('[AuthHook] loader() called');
-                try {
-                    const authData = await auth();
-                    if (authData && 'key' in authData) {
-                        const k = authData.key;
-                        saveConfig({ apiKey: k });
-                        return { apiKey: k };
-                    }
-                }
-                catch (e) {
-                    log(`[AuthHook] loader error: ${e}`);
-                }
-                const config = loadConfig();
-                if (config.apiKey)
-                    return { apiKey: config.apiKey };
-                return {};
-            },
-            methods: [{
-                    type: 'api',
-                    label: 'Pollinations API Key',
-                    prompts: [{
-                            type: 'text',
-                            key: 'apiKey',
-                            message: 'Enter Pollinations API Key (starts with sk_)',
-                            validate: (v) => (!v || v.length < 10) ? 'Invalid key' : undefined
-                        }],
-                    authorize: async (inputs) => {
-                        log(`[AuthHook] authorize() called`);
-                        if (!inputs?.apiKey)
-                            return { type: 'failed' };
-                        try {
-                            const r = await fetch('https://gen.pollinations.ai/text/models', {
-                                headers: { 'Authorization': `Bearer ${inputs.apiKey}` }
-                            });
-                            if (r.ok) {
-                                log('[AuthHook] Success. Saving & Refreshing Config...');
-                                saveConfig({ apiKey: inputs.apiKey });
-                                // CRITICAL: Refresh config IMMEDIATELY after successful auth
-                                await refreshProviderConfig();
-                                return { type: 'success', key: inputs.apiKey };
-                            }
-                        }
-                        catch (e) {
-                            log(`[AuthHook] Auth error: ${e}`);
-                        }
-                        return { type: 'failed' };
-                    }
-                }]
-        },
-        // Event hook removed (logic moved to authorize)
-        event: async ({ event }) => { },
+        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) {
@@ -224,19 +102,18 @@ 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.`);
         },
         ...toastHooks,
+        ...createToolHooks(ctx.client),
         ...createStatusHooks(ctx.client),
         ...commandHooks
     };

package/dist/server/commands.d.ts

@@ -9,8 +9,10 @@ interface CommandResult {
     response?: string;
     error?: string;
 }
+export declare function setClientForCommands(client: any): void;
 export declare function handleCommand(command: string): Promise<CommandResult>;
 export declare function createCommandHooks(): {
     'tui.command.execute': (input: any, output: any) => Promise<void>;
+    'command.execute.before': (input: any, output: any) => Promise<void>;
 };
 export {};

package/dist/server/commands.js

@@ -130,6 +130,10 @@ function calculateCurrentPeriodStats(usage, lastReset, tierLimit) {
     };
 }
 // === COMMAND HANDLER ===
+let globalClient = null;
+export function setClientForCommands(client) {
+    globalClient = client;
+}
 export async function handleCommand(command) {
     const parts = command.trim().split(/\s+/);
     if (!parts[0].startsWith('/poll')) {
@@ -150,6 +154,22 @@ export async function handleCommand(command) {
             return handleConfigCommand(args);
         case 'help':
             return handleHelpCommand();
+        case 'addKey': // Internal command for UI
+            if (globalClient) {
+                globalClient.tui.appendPrompt({ value: "/pollinations rmbg_key_add " }); // Using the old command? No, use tool?
+                // Wait, tools are not commands.
+                // But we removed rmbg_key_add command!
+                // We should instruct user to use the tool?
+                // Or user types: rmbg_keys { action: "add", key: "..." }
+                // That's painful to type.
+                // Can we alias a command to a tool call?
+                // /pollinations rmbg_key_add is GONE.
+                // Let's re-introduce a helper command just for this UI flow?
+                // Or better: appendPrompt({ value: 'rmbg_keys { action: "add", key: "' });
+                globalClient.tui.appendPrompt({ value: 'rmbg_keys { action: "add", key: "' });
+                return { handled: true };
+            }
+            return { handled: true, error: "TUI not available" };
         default:
             return {
                 handled: true,
@@ -303,15 +323,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 +356,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 +371,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) {
@@ -432,17 +462,21 @@ function handleConfigCommand(args) {
 }
 function handleHelpCommand() {
     const help = `
-### 🌸 Pollinations Plugin - Commandes V5
+### 🌸 Pollinations Plugin - Commandes V6
 
+**Mode & Usage**
 - **\`/pollinations mode [mode]\`**: Change le mode (manual, alwaysfree, pro).
 - **\`/pollinations usage [full]\`**: Affiche le dashboard (full = détail).
-- **\`/pollinations fallback <main> [agent]\`**: Configure le Safety Net (Free).
+- **\`/pollinations fallback <main> [agent]\`**: Configure le Safety Net.
+
+**Configuration**
 - **\`/pollinations config [key] [value]\`**:
-  - \`status_gui\`: none, alert, all (Status Dashboard).
-  - \`logs_gui\`: none, error, verbose (Logs Techniques).
-  - \`threshold_tier\`: 0-100 (Alerte %).
-  - \`threshold_wallet\`: 0-100 (Safety Net %).
-  - \`status_bar\`: true/false (Widget).
+  - \`status_gui\`: none, alert, all
+  - \`logs_gui\`: none, error, verbose
+  - \`threshold_tier\` / \`threshold_wallet\`: 0-100
+  - \`status_bar\`: true/false
+
+> 💡 **RMBG keys**: Use the \`rmbg_keys\` tool (works with any model).
 `.trim();
     return { handled: true, response: help };
 }
@@ -450,16 +484,44 @@ function handleHelpCommand() {
 export function createCommandHooks() {
     return {
         'tui.command.execute': async (input, output) => {
-            const result = await handleCommand(input.command);
-            if (result.handled) {
-                output.handled = true;
-                if (result.response) {
-                    output.response = result.response;
-                }
-                if (result.error) {
-                    output.error = result.error;
+            if (!input.command.startsWith('/pollinations')) {
+                return;
+            }
+            try {
+                // Parse command
+                const rawArgs = input.command.replace('/pollinations', '').trim();
+                const result = await handleCommand(rawArgs);
+                if (result.handled) {
+                    if (result.error) {
+                        output.error = `❌ **Erreur:** ${result.error}`;
+                    }
+                    else if (result.response) {
+                        output.response = result.response;
+                    }
+                    // If no response and no error, assume handled silently (like appendPrompt)
                 }
             }
+            catch (err) {
+                output.error = `❌ **Erreur Critique:** ${err.message}`;
+            }
+        },
+        // Hook for UI Commands (Palette / Buttons)
+        'command.execute.before': async (input, output) => {
+            const cmd = input.command;
+            if (cmd === 'pollinations.addKey') {
+                handleCommand('addKey'); // Trigger UI helper
+            }
+            else if (cmd === 'pollinations.usage') {
+                const res = await handleCommand('usage');
+                // For native commands, we might need a different way to show output if not in chat context
+                // But here we are likely in a context where we can't easily hijack output unless we use a toast or open a file?
+                // Let's use toast for simple feedback or appendPrompt for complex interaction.
+                if (res.response)
+                    globalClient?.tui.showToast({ title: "Pollinations Usage", metadata: { type: 'info', message: "Usage info sent to chat/logs" } });
+            }
+            else if (cmd === 'pollinations.mode') {
+                globalClient?.tui.appendPrompt({ value: "/pollinations mode " });
+            }
         }
     };
 }

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 {};