opencode-pollinations-plugin 6.1.0-beta.12 → 6.1.0-beta.22

package/README.md

@@ -7,7 +7,7 @@
   Free AI models, multimodal generation, and smart quota management — directly in your editor.
   <br><br>
 
-![Version](https://img.shields.io/badge/version-6.1.0--beta-blue.svg)
+![Version](https://img.shields.io/badge/version-6.1.0--beta.22-blue.svg)
 ![Downloads](https://img.shields.io/npm/dt/opencode-pollinations-plugin?label=downloads&color=brightgreen)
 ![License](https://img.shields.io/badge/license-MIT-green.svg)
 ![Status](https://img.shields.io/badge/status-Beta-orange.svg)
@@ -23,12 +23,13 @@
 
 ---
 
-## ✨ What's New in v6.1-beta
+## ✨ What's New in v6.1-beta.22
 
 The jump from v5.9 to v6.1 is not incremental. The plugin has grown from a smart proxy into a **full multimodal agent toolkit**:
 
 - **15+ native tools** for generation, design, and media processing — usable directly in OpenCode's agent mode
-- **Ledger quota system**: local `~/.pollinations/usage_history.json` tracking for 100% accurate usage with zero lag
+- **Smart Fetch Quota**: 100% exact math fetching directly from Pollinations API for quota verification (zero local cache)
+- **Dynamic Pricing**: Tool costs are estimated live based on Tinybird API model stats. Token models have a built-in max theoretical threshold limit (Cost Guard).
 - **Stealth notifications**: status toasts now only fire in relevant contexts, no more noise
 - **Background removal** with multi-key rotation and automatic fallback to free provider
 - **Video, music, audio generation** via the Pollinations API
@@ -49,7 +50,9 @@ Then in OpenCode:
 ```
 Select **pollinations** → Enter your API key from [enter.pollinations.ai](https://enter.pollinations.ai), or leave blank to use the free tier.
 
-Select any `pollinations/*` model and start chatting. **No key required to get started.**
+Select any `pollinations/*` text model and start chatting. **No key required for text.**
+
+> ⚠️ **Note:** Image generation (`gen_image`) requires a Pollinations API Key. Text models remain free.
 
 > ⚠️ After connecting a new key, restart OpenCode once for the model list to update.
 
@@ -98,13 +101,14 @@ These tools call the Pollinations APIs directly, enabling the AI to generate med
 
 | Tool | Description |
 |------|-------------|
-| `gen_image` | Generate images from a text prompt (Flux, SDXL, etc.) |
+| `gen_image` | Generate images from a text prompt (Flux, SDXL, etc.) **[Requires Key]** |
 | `gen_audio` | Generate speech or sound effects |
 | `gen_music` | Generate music from a description |
 | `gen_video` | Generate short video clips |
 | `transcribe_audio` | Transcribe an audio file to text |
 | `deepsearch` | Multi-step AI-powered research |
 | `search_crawl_scrape` | Web search with full page scraping |
+| `beta_discovery` | Probe undocumented model parameters (400 validation extraction) |
 
 ### 🖌️ Design Tools
 
@@ -236,7 +240,8 @@ Config is read from (highest priority first):
 ### ✅ Shipped (v5.x → v6.1-beta)
 - Free + Enterprise proxy with transparent fallback (Safety Net)
 - Dynamic port allocation — cross-platform (no more `fuser`, no port conflicts)
-- Pollen/tier quota tracking with local Ledger
+- Pollen/tier quota tracking with Smart Fetch API (no local logging)
+- Dynamic Pricing (Tinybird stats) and Cost Guard max thresholds
 - Agent tools: image, audio, music, video generation
 - Agent tools: web search, scraping, deep research
 - Design tools: diagrams, palettes, QR codes

package/dist/index.js

@@ -1,7 +1,6 @@
 import * as http from 'http';
-import * as fs from 'fs';
 import { generatePollinationsConfig } from './server/generate-config.js';
-import { loadConfig } from './server/config.js';
+import { loadConfig, migrateLegacyConfig } from './server/config.js';
 import { handleChatCompletion } from './server/proxy.js';
 import { createToastHooks, createToolHooks, setGlobalClient } from './server/toast.js';
 import { createStatusHooks } from './server/status.js';
@@ -9,14 +8,9 @@ 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';
-function log(msg) {
-    try {
-        fs.appendFileSync(LOG_FILE, `[${new Date().toISOString()}] ${msg}\n`);
-    }
-    catch (e) { }
-}
-// Port killing removed: Using dynamic ports.
+import { log } from './server/logger.js';
+import { ModelRegistry } from './server/models/index.js';
+const sessionModels = new Map();
 const startProxy = () => {
     return new Promise((resolve) => {
         const server = http.createServer(async (req, res) => {
@@ -80,10 +74,22 @@ const startProxy = () => {
 export const PollinationsPlugin = async (ctx) => {
     const v = require('../package.json').version;
     log(`Plugin Initializing v${v}...`);
+    log(`[ENV] Keys: ${Object.keys(process.env).filter(k => k.includes('OPENCODE') || k.includes('APP') || k.includes('DATA')).join(', ')}`);
     console.log(`🚀 POLLINATIONS PLUGIN v${v} LOADED 🚀`);
+    // MIGRATE CONFIG
+    migrateLegacyConfig();
     // START PROXY
     const port = await startProxy();
     const localBaseUrl = `http://127.0.0.1:${port}/v1`;
+    // INIT MODEL REGISTRY (non-blocking, fire-and-forget)
+    ModelRegistry.refresh().then(() => {
+        const stats = ModelRegistry.stats();
+        log(`[ModelRegistry] Ready: ${stats.image} image, ${stats.video} video, ${stats.audio} audio, ${stats.text} text`);
+        // Démarrage du patcher asynchrone des descriptions des Outils (Phase 1.5)
+        import('./server/models/worker.js').then(module => {
+            module.ToolRegistryWorker.start();
+        }).catch(e => log(`[ToolWorker] Failed to load worker: ${e}`));
+    }).catch(e => log(`[ModelRegistry] Init failed (will use fallback): ${e}`));
     setGlobalClient(ctx.client);
     setClientForCommands(ctx.client);
     const toastHooks = createToastHooks(ctx.client);
@@ -92,6 +98,24 @@ export const PollinationsPlugin = async (ctx) => {
     const toolRegistry = createToolRegistry();
     log(`[Tools] ${Object.keys(toolRegistry).length} tools registered`);
     return {
+        "chat.message": async (input) => {
+            const m = input.model;
+            if (m) {
+                if (m.modelID && !m.modelID.includes('pollimock-handler')) {
+                    sessionModels.set(input.sessionID, `${m.providerID}/${m.modelID}`);
+                    log(`[Hook] Saved active model ${m.providerID}/${m.modelID} for session ${input.sessionID}`);
+                }
+                else if (m.modelID && m.modelID.includes('pollimock-handler')) {
+                    const prev = sessionModels.get(input.sessionID);
+                    if (prev) {
+                        log(`[Hook] Virtual model triggered. Reverting to ${prev} in 500ms...`);
+                        setTimeout(() => {
+                            ctx.client.tui.executeCommand({ body: { command: `/model ${prev}` } }).catch(console.error);
+                        }, 500);
+                    }
+                }
+            }
+        },
         tool: toolRegistry,
         async config(config) {
             log("[Hook] config() called");
@@ -106,6 +130,12 @@ export const PollinationsPlugin = async (ctx) => {
                 config.provider = {};
             // Dynamic Provider Name
             const version = require('../package.json').version;
+            // Inject Virtual Handler Model
+            modelsObj['pollimock-handler'] = {
+                id: 'pollimock-handler',
+                name: 'Command Handler (Virtual)',
+                options: { hidden: true } // Try to hide from UI if OpenCode supports it
+            };
             config.provider['pollinations'] = {
                 id: 'pollinations',
                 name: `Pollinations AI (v${version})`,

package/dist/server/commands.d.ts

@@ -11,6 +11,10 @@ interface CommandResult {
 }
 export declare function setClientForCommands(client: any): void;
 export declare function handleCommand(command: string): Promise<CommandResult>;
+export declare function handleUsageCommand(args: string[]): Promise<CommandResult>;
+export declare function handleModelsCommand(args: string[]): Promise<CommandResult>;
+export declare function handlePricingCommand(): Promise<CommandResult>;
+export declare function handleInfosCommand(): Promise<CommandResult>;
 export declare function createCommandHooks(): {
     'tui.command.execute': (input: any, output: any) => Promise<void>;
     'command.execute.before': (input: any, output: any) => Promise<void>;

package/dist/server/commands.js

@@ -1,9 +1,9 @@
 import * as https from 'https';
-import { loadConfig, saveConfig } from './config.js';
-import { getQuotaStatus } from './quota.js';
+import { loadConfig, saveConfig, saveKeyToAuthJson } from './config.js';
+import { getQuotaStatus, fetchUsageForPeriod } from './quota.js';
 import { emitStatusToast } from './toast.js';
-import { getDetailedUsage } from './pollinations-api.js';
 import { generatePollinationsConfig } from './generate-config.js';
+import { ModelRegistry } from './models/index.js';
 function checkEndpoint(ep, key) {
     return new Promise((resolve) => {
         const req = https.request({
@@ -155,6 +155,12 @@ export async function handleCommand(command) {
             return handleConfigCommand(args);
         case 'help':
             return handleHelpCommand();
+        case 'models':
+            return await handleModelsCommand(args);
+        case 'pricing':
+            return await handlePricingCommand();
+        case 'infos':
+            return await handleInfosCommand();
         case 'addKey': // External trigger
             // UI Pollution Fix: User hates appendPrompt.
             // Just return a message telling them to use the tool.
@@ -225,7 +231,7 @@ async function handleModeCommand(args) {
         response: `✅ Mode changé: ${mode}`
     };
 }
-async function handleUsageCommand(args) {
+export async function handleUsageCommand(args) {
     const isFull = args[0] === 'full';
     try {
         const quota = await getQuotaStatus(true);
@@ -245,10 +251,10 @@ async function handleUsageCommand(args) {
                 response += `\n> ⚠️ *Votre clé API ne permet pas l'accès aux détails d'usage (Restriction).*`;
             }
             else {
-                const usageData = await getDetailedUsage(config.apiKey);
-                if (usageData && usageData.usage) {
-                    const lastReset = calculateResetDate(quota.nextResetAt);
-                    const stats = calculateCurrentPeriodStats(usageData.usage, lastReset, quota.tierLimit);
+                const lastReset = calculateResetDate(quota.nextResetAt);
+                const usageData = await fetchUsageForPeriod(config.apiKey, lastReset);
+                if (usageData && usageData.length > 0) {
+                    const stats = calculateCurrentPeriodStats(usageData, 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`;
@@ -321,6 +327,7 @@ async function handleConnectCommand(args) {
         if (enterpriseModels.length > 0) {
             // SUCCESS
             saveConfig({ apiKey: key }); // Don't force mode 'pro'. Let user decide.
+            saveKeyToAuthJson(key); // NATIVE SYNC: Hot-reload on OpenCode bypasses restart requirement !
             const masked = key.substring(0, 6) + '...';
             // Count Paid Only models found
             const diamondCount = enterpriseModels.filter(m => m.name.includes('💎')).length;
@@ -351,7 +358,7 @@ async function handleConnectCommand(args) {
             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}`
+                response: `✅ **Connexion Réussie! (Injection à chaud)**\n- Clé: \`${masked}\`\n- Modèles Pro Débloqués: ${enterpriseModels.length} (dont ${diamondCount} 💎 Paid)${forcedModeMsg}`
             };
         }
         else {
@@ -391,9 +398,29 @@ function handleConfigCommand(args) {
     const [key, value] = args;
     if (!key) {
         const config = loadConfig();
+        const k = config.apiKey ? (config.apiKey.length > 8 ? `${config.apiKey.substring(0, 5)}****${config.apiKey.substring(config.apiKey.length - 4)}` : '****') : 'Non configurée';
+        const markdownResponse = `## ⚙️ Configuration Pollinations
+Voici l'état actuel de votre configuration locale.
+
+| Paramètre | Valeur Actuelle | Rôle | Commande |
+|-----------|-----------------|------|----------|
+| **apiKey** | \`${k}\` | Votre clé API secrète (BYOK) | \`/pollinations connect <key>\` |
+| **mode** | \`${config.mode}\` | Mode d'accès | \`/pollinations mode <manual/pro/alwaysfree>\` |
+| **enablePaidTools**| \`${config.enablePaidTools ?? true}\` | Sécurité: Désactiver outils payants | \`/poll config enablePaidTools <true/false>\` |
+| **costConfirmationRequired**| \`${config.costConfirmationRequired ?? true}\` | Demande confirmation si le seuil d'alerte est dépassé | \`/poll config costConfirmation <true/false>\` |
+| **costThreshold**| \`${config.costThreshold ?? 0.15} 🌻\` | Seuil d'alerte coût Outils | \`/poll config costThreshold <X>\` |
+| **cost_estimator**| \`${config.costEstimator ?? true}\` | Afficher l'estimation de coût dans les Toasts | \`/poll config cost_estimator <true/false>\` |
+| **fallbacks.free.main** | \`${config.fallbacks?.free?.main || 'free/mistral'}\` | Modèle de repli Chat vers l'univers free legacy | \`/pollinations fallback <main> <agent>\` |
+| **fallbacks.free.agent** | \`${config.fallbacks?.free?.agent || 'free/openai-fast'}\`| Modèle de repli Agent vers l'univers free legacy | \`/pollinations fallback <main> <agent>\` |
+| **fallbacks.enter.agent** | \`${config.fallbacks?.enter?.agent || 'free/openai-fast'}\`| Modèle Agent principal (free/* ou enter/*) | *Géré automatiquement* |
+| **status_gui** | \`${config.gui?.status || 'all'}\` | Toasts de statut (all, alert, none) | \`/poll config status_gui <all/alert/none>\` |
+| **logs_gui** | \`${config.gui?.logs || 'error'}\` | Niveau de log (verbose, error) | \`/poll config logs_gui <verbose/error/none>\` |
+| **threshold_tier** | \`${config.thresholds?.tier || 80}%\` | Alerte limite Quotidienne Gratuite | \`/poll config threshold_tier <1-100>\` |
+| **threshold_wallet** | \`${config.thresholds?.wallet || 80}%\` | Alerte baisse de Wallet Premium | \`/poll config threshold_wallet <1-100>\` |
+| **status_bar** | \`${config.statusBar ?? true}\` | Affiche l'icône dans la barre de statut | \`/poll config status_bar <true/false>\` |`;
         return {
             handled: true,
-            response: JSON.stringify(config, null, 2)
+            response: markdownResponse
         };
     }
     if (key === 'toast_verbosity' && value) {
@@ -453,9 +480,27 @@ function handleConfigCommand(args) {
         saveConfig({ ...config, costEstimator: enabled });
         return { handled: true, response: `✅ cost_estimator = ${enabled}` };
     }
+    if (key === 'enablePaidTools' && value) {
+        const enabled = value === 'true';
+        saveConfig({ enablePaidTools: enabled });
+        return { handled: true, response: `✅ enablePaidTools = ${enabled}${!enabled ? ' (wallet protection active)' : ''}` };
+    }
+    if (key === 'costThreshold' && value) {
+        const threshold = parseFloat(value);
+        if (isNaN(threshold) || threshold < 0) {
+            return { handled: true, error: 'Valeur numérique positive requise (en pollen). Ex: 0.15' };
+        }
+        saveConfig({ costThreshold: threshold });
+        return { handled: true, response: `✅ costThreshold = ${threshold} 🌻` };
+    }
+    if (key === 'costConfirmation' && value) {
+        const enabled = value === 'true';
+        saveConfig({ costConfirmationRequired: enabled });
+        return { handled: true, response: `✅ costConfirmationRequired = ${enabled}` };
+    }
     return {
         handled: true,
-        error: `Clé inconnue: ${key}. Clés: status_gui, logs_gui, threshold_tier, threshold_wallet, status_bar, cost_estimator`
+        error: `Clé inconnue: ${key}. Clés: status_gui, logs_gui, threshold_tier, threshold_wallet, status_bar, cost_estimator, enablePaidTools, costThreshold, costConfirmation`
     };
 }
 function handleHelpCommand() {
@@ -469,16 +514,255 @@ function handleHelpCommand() {
 
 **Configuration**
 - **\`/pollinations config [key] [value]\`**:
-  - \`status_gui\`: none, alert, all
+   - \`status_gui\`: none, alert, all
   - \`logs_gui\`: none, error, verbose
   - \`threshold_tier\` / \`threshold_wallet\`: 0-100
   - \`status_bar\`: true/false
   - \`cost_estimator\`: true/false (show cost in outputs)
+  - \`enablePaidTools\`: true/false (wallet protection)
+  - \`costThreshold\`: seuil en pollen (défaut: 0.15)
+  - \`costConfirmation\`: true/false (confirmation coût)
+
+**Modèles & Pricing**
+- **\`/pollinations models [type]\`**: Liste des modèles (type: image, video, audio, text)
+- **\`/pollinations pricing\`**: Tableau de pricing détaillé
+- **\`/pollinations infos\`**: Explications sur les Tiers et le Pollen
 
 > 💡 **RMBG keys**: Use the \`rmbg_keys\` tool (works with any model).
 `.trim();
     return { handled: true, response: help };
 }
+// === MODELS & PRICING COMMANDS ===
+function parseNameDesc(m) {
+    const fullDesc = m.description || m.name;
+    const parts = fullDesc.split(" - ");
+    if (parts.length > 1) {
+        return { nom: parts[0].trim(), desc: parts.slice(1).join(" - ").trim() };
+    }
+    return { nom: fullDesc, desc: "" };
+}
+export async function handleModelsCommand(args) {
+    const filter = args[0]; // optional: image, video, audio, text
+    if (!ModelRegistry.isReady()) {
+        return {
+            handled: true,
+            response: '⏳ Le registre des modèles est en cours de chargement. Réessayez dans quelques secondes.'
+        };
+    }
+    const sections = [];
+    // --- FETCH FREE UNIVERSE GITHUB/LEGACY MODELS ---
+    if (!filter || filter === 'text') {
+        try {
+            const freeRes = await fetch('https://text.pollinations.ai/models', { signal: AbortSignal.timeout(4000) });
+            if (freeRes.ok) {
+                const freeData = await freeRes.json();
+                sections.push('## 🎁 Modèles Free Universe (Communautaire / Legacy API)\n');
+                sections.push(`> *Bonus gratuit disponible sans clé via l'API \`text.pollinations.ai\`. Dédié au Chat textuel.*\n`);
+                sections.push('| Nom | Alias / ID | Description | Vision | Tools |');
+                sections.push('|-----|------------|-------------|--------|-------|');
+                for (const m of freeData) {
+                    const desc = m.description || m.name;
+                    const aliases = m.aliases ? m.aliases.join(', ') : m.name;
+                    sections.push(`| \`${m.name}\` | ${aliases} | ${desc.substring(0, 40)} | ${m.vision ? '👁️' : '❌'} | ${m.tools ? '🛠️' : '❌'} |`);
+                }
+                sections.push('');
+            }
+        }
+        catch (e) {
+            sections.push('## 🎁 Modèles Free Universe\n*(⚠️ L\'API communautaire text.pollinations.ai semble temporairement indisponible)*\n');
+        }
+    }
+    sections.push('## 📋 Modèles Pollinations Enter (Principaux)\n');
+    const categories = [
+        { cat: 'image', emoji: '🎨', label: 'Image' },
+        { cat: 'video', emoji: '🎬', label: 'Video' },
+        { cat: 'audio', emoji: '🔊', label: 'Audio' },
+        { cat: 'text', emoji: '📝', label: 'Text' },
+    ];
+    for (const { cat, emoji, label } of categories) {
+        if (filter && filter !== cat)
+            continue;
+        const models = ModelRegistry.list(cat);
+        if (models.length === 0)
+            continue;
+        const sorted = [...models].sort((a, b) => a.name.localeCompare(b.name));
+        sections.push(`### ${emoji} ${label} (${models.length} modèles)\n`);
+        sections.push('| Nom | ID | Description | Capabilities | Input | Output |');
+        sections.push('|-----|----|-------------|--------------|-------|--------|');
+        for (const m of sorted) {
+            const { nom, desc } = parseNameDesc(m);
+            const badges = buildBadges(m);
+            const input = buildInputIcons(m);
+            const output = buildOutputCost(m);
+            sections.push(`| ${nom} | \`${m.name}\` | ${desc.substring(0, 40)} | ${badges} | ${input} | ${output} |`);
+        }
+        sections.push('');
+    }
+    sections.push('> **Capabilities** : 👁️ vision · 🧠 reasoning · 🎙️ audio in · 🔍 search · 🔊 audio out · 💻 code exec');
+    sections.push('> **Other** : 💎 PAID ONLY (Wallet direct) · 📏 Contexte API max');
+    return { handled: true, response: sections.join('\n') };
+}
+export async function handlePricingCommand() {
+    try {
+        const cp = require('child_process');
+        const path = require('path');
+        // Pointeur __dirname -> dist/server. Donc on cible scripts/pollinations_pricing.js
+        const scriptPath = path.join(__dirname, 'scripts', 'pollinations_pricing.js');
+        // Exécution locale via Node (sécurisé pour le bundle prod, pas de npx tsx)
+        const output = cp.execSync(`node "${scriptPath}"`, { encoding: 'utf-8', stdio: 'pipe' });
+        return { handled: true, response: output };
+    }
+    catch (e) {
+        return { handled: true, error: `Erreur lors de la récupération des prix: ${e.message}` };
+    }
+}
+// ─── Formatting Helpers for Models/Pricing ────────────────────────────────
+function buildBadges(m) {
+    const f = [];
+    if (m.paid_only)
+        f.push('💎');
+    const allFlags = [...(m.input_modalities || []), ...(m.output_modalities || []), m.name];
+    if (m.supportsI2X)
+        allFlags.push("👁️");
+    const str = allFlags.join(" ").toLowerCase();
+    if (str.includes("image") || str.includes("👁️"))
+        f.push("👁️");
+    if (m.reasoning || str.includes("reasoning"))
+        f.push("🧠");
+    if (str.includes("audio") || str.includes("whisper") || str.includes("scribe") || str.includes("🎙️"))
+        f.push("🎙️");
+    if (str.includes("search") || str.includes("sonar") || str.includes("gemini"))
+        f.push("🔍");
+    if (m.output_modalities.includes("audio") || (m.voices && m.voices.length > 0) || str.includes("tts") || str.includes("music"))
+        f.push("🔊");
+    if (str.includes("coder") || str.includes("code") || str.includes("gemini"))
+        f.push("💻");
+    return f.filter((v, i, a) => a.indexOf(v) === i).join(" ");
+}
+function buildInputIcons(m) {
+    const icons = [];
+    if (m.input_modalities.includes('text'))
+        icons.push('📝');
+    if (m.input_modalities.includes('image'))
+        icons.push('🖼️');
+    if (m.input_modalities.includes('audio'))
+        icons.push('🎤');
+    return icons.join('') || '📝';
+}
+function buildOutputCost(m) {
+    const p = m.pricing;
+    if (p.completionImageTokens) {
+        return p.completionImageTokens < 0.0001
+            ? `~tokens`
+            : `${p.completionImageTokens} 🌻/img`;
+    }
+    if (p.completionVideoSeconds)
+        return `${p.completionVideoSeconds} 🌻/s`;
+    if (p.completionVideoTokens)
+        return `~tokens/s`;
+    if (p.completionAudioTokens)
+        return `${p.completionAudioTokens} 🌻/tok`;
+    if (p.completionAudioSeconds)
+        return `${p.completionAudioSeconds} 🌻/s`;
+    if (p.promptAudioSeconds)
+        return `${p.promptAudioSeconds} 🌻/s`;
+    if (p.completionTextTokens)
+        return `${p.completionTextTokens} 🌻/tok`;
+    return '~tokens';
+}
+export async function handleInfosCommand() {
+    const config = loadConfig();
+    let name = "Developer";
+    let tier = "anonymous";
+    if (config.apiKey) {
+        try {
+            const res = await fetch('https://gen.pollinations.ai/account/profile', {
+                headers: { 'Authorization': `Bearer ${config.apiKey}` }
+            });
+            if (res.ok) {
+                const data = await res.json();
+                if (data.name)
+                    name = data.name;
+                tier = data.tier || "anonymous";
+            }
+        }
+        catch (e) {
+            // Ignorer l'erreur réseau et garder les valeurs par défaut
+        }
+    }
+    const emojis = {
+        microbe: '🦠', spore: '🍄', seed: '🌱', flower: '🌸', nectar: '🍯', anonymous: '👤'
+    };
+    const tierEmoji = emojis[tier] || '❓';
+    const response = `## 🍯💚 POLLINATIONS OPENCODE PLUGIN 💚🍯
+
+Bienvenue **${name}** sur le plugin Pollinations pour OpenCode !
+
+Ce plugin vous permet de générer du code, des images, d'analyser des vidéos et interagir avec les meilleurs modèles d'Intelligence Artificielle de manière totalement transparente et intégrée à votre environnement de travail. Accédez aux capacités des LLMs de pointe, que ce soit via des requêtes de chat, la refonte de votre base de code, ou directement dans le terminal.
+ 
+**Ce Que ce plugin vous apporte en plus ! :**
+
+**🛠️ Outils Gratuits Intégrés (Toujours disponibles) :**
+- \`gen_qrcode\` / \`gen_diagram\` / \`gen_palette\` : Outils visuels et dev.
+- \`remove_background\` : Détourage d'image natif.
+- \`extract_frames\` / \`extract_audio\` : Extraction rapide de contenu média.
+- \`file_to_url\` : Hébergement instantané de vos fichiers locaux en ligne.
+
+**💎 Outils Pollinations (Premium - Automatisés avec votre Clé) :**
+- \`polli_gen_image\` : Génération d'images (Flux, Seedream, Gemini) + support Image-to-Image.
+- \`polli_gen_video\` : Génération vidéo text-to-video / image-to-video (Veo, Wan, LTX...).
+- \`polli_gen_audio\`/\`polli_stt\` : Transcription Whisper, Text-to-Speech ElevenLabs.
+- \`polli_gen_music\` : Moteur de musique générative.
+- \`polli_web_search\` : Recherche connectée pour étendre la base de contexte de l'agent.
+
+- **Une configuration granulaire**, des modes de gestions de vos tokens et de vos outils, de la sécurisation des coûts des outils consommant du pollen...
+
+---
+
+> **Your tiers:** ${tierEmoji} ${tier.toUpperCase()}
+
+---
+
+## 🌍 Qu'est-ce que pollinations.ai ?
+pollinations.ai est une plateforme d'IA open-source construite par et pour la communauté. Nous offrons une API unifiée pour les images, le texte, l'audio et la vidéo. Tout fonctionne de manière ouverte : notre code, notre feuille de route, nos conversations. Des centaines de développeurs construisent déjà des outils, des jeux, des bots et des expériences farfelues avec nous. Vous êtes les bienvenus !
+
+Pas de boîtes noires. Pas de dépendance exclusive (vendor lock-in). Juste une API conviviale et un Discord rempli de personnes qui s'entraident réellement.
+
+---
+
+## 📈 Évoluez votre Palier (Tier)
+Pour les développeurs qui créent avec pollinations.ai. Montez de niveau pour gagner plus de Pollen quotidien.
+
+- 🦠 **Microbe** (0.1 pollen/jour) : Pour débloquer : S'inscrire
+- 🍄 **Spore** (1 pollen/jour) : Pour débloquer : Vérification automatique (Vérifié à l'inscription)
+- 🌱 **Seed** (3 pollen/jour) : Pour débloquer : 8+ points dev (Mise à niveau automatique hebdomadaire)
+- 🌸 **Flower** (10 pollen/jour) : Pour débloquer : Publier une application (🌱 Doit être Seed en premier)
+- 🍯 **Nectar** (20 pollen/jour) : Bientôt disponible 🔮
+
+✨ *Nous sommes en bêta ! Nous apprenons ce qui fonctionne le mieux pour notre communauté et pourrons ajuster les valeurs de pollen et les règles des paliers. Merci de faire partie de cette aventure !*
+
+---
+
+## 💎 Qu'est-ce que le Pollen ?
+Faire tourner des modèles d'IA coûte de l'argent. Le Pollen est notre moyen de faire fonctionner les serveurs sans publicité ni revente de vos données. Un crédit simple et unique pour tous les modèles — prévisible, transparent, sans surprises. 
+
+**$1 ≈ 1 Pollen** (les prix peuvent évoluer). Vous le dépensez pour faire des appels API.
+
+## 🛒 Comment obtenir du Pollen ?
+Il y a trois moyens d'ajouter du Pollen à votre solde :
+
+1. **L'acheter** : Achetez des packs de Pollen directement par carte bancaire. Ce Pollen va dans votre portefeuille (wallet) et n'expire jamais. Des packs simples, pas d'abonnements, pas de paliers bloquants.
+2. **Pollen Quotidien** : Pendant et après la bêta, les développeurs inscrits reçoivent des subventions quotidiennes de Pollen pour soutenir leurs expérimentations, en fonction de leur palier (microbe, spore, seed, flower, nectar).
+3. **Le Gagner** : Complétez des récompenses communautaires ponctuelles (comme aider à résoudre un problème technique ou contribuer au projet). Chaque contribution vous fait gagner du Pollen. Nous le remarquons et nous partageons.
+
+---
+
+### 💡 Comment le Pollen est-il dépensé ?
+1. **Les subventions quotidiennes (Tier grants)** sont utilisées en premier.
+2. **Le Pollen acheté (Wallet)** est utilisé une fois le Pollen quotidien épuisé.
+⚠️ **Exception** : 💎 Les modèles *Paid Only* (ex: claude-large, veo, seedream-pro) requièrent uniquement du Pollen acheté.`;
+    return { handled: true, response };
+}
 // === INTEGRATION OPENCODE ===
 export function createCommandHooks() {
     return {

package/dist/server/config.d.ts

@@ -1,3 +1,6 @@
+export declare function getConfigDir(): string;
+export declare const CONFIG_DIR: string;
+export declare const CONFIG_FILE: string;
 export interface PollinationsConfigV5 {
     version: string | number;
     mode: 'manual' | 'alwaysfree' | 'pro';
@@ -55,3 +58,5 @@ export declare function saveConfig(updates: Partial<PollinationsConfigV5>): {
     statusBar: boolean;
     costEstimator: boolean;
 };
+export declare function saveKeyToAuthJson(key: string): boolean;
+export declare function migrateLegacyConfig(): void;