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

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({
@@ -57,6 +57,7 @@ export async function checkKeyPermissions(key) {
 }
 // === CONSTANTS & PRICING ===
 const TIER_LIMITS = {
+    microbe: { pollen: 0.1, emoji: '🦠' },
     spore: { pollen: 1, emoji: '🦠' },
     seed: { pollen: 3, emoji: '🌱' },
     flower: { pollen: 10, emoji: '🌸' },
@@ -130,6 +131,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 +155,19 @@ 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.
+            return {
+                handled: true,
+                response: "💡 Pour ajouter une clé : Utilisez l'outil `rmbg_keys`\nExemple : `rmbg_keys action=add key=bkgc_...`"
+            };
         default:
             return {
                 handled: true,
@@ -202,7 +220,7 @@ async function handleModeCommand(args) {
             return { handled: true, error: `❌ Erreur de vérification: ${e.message}` };
         }
     }
-    // Allow switch (if economy or manual, or verified pro)
+    // Allow switch (if alwaysfree or manual, or verified pro)
     saveConfig({ mode: mode });
     const config = loadConfig();
     if (config.gui.status !== 'none') {
@@ -213,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);
@@ -233,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`;
@@ -264,36 +282,32 @@ async function handleUsageCommand(args) {
     }
 }
 function handleFallbackCommand(args) {
-    const [mode, model] = args;
-    if (!mode) {
+    const [main, agent] = args;
+    if (!main) {
         const config = loadConfig();
+        const freeConfig = `Free: main=${config.fallbacks.free.main}, agent=${config.fallbacks.free.agent}`;
+        const enterConfig = `Enter: agent=${config.fallbacks.enter.agent}`;
         return {
             handled: true,
-            response: `Fallbacks actuels:\n- Economy: ${config.fallbacks.economy}\n- Pro: ${config.fallbacks.pro}`
+            response: `Fallbacks actuels:\n${freeConfig}\n${enterConfig}`
         };
     }
+    // Default behavior for "/poll fallback <model> <agent>" is setting FREE fallbacks
+    // User needs to use commands (maybe add /poll fallback enter ...) later
+    // For now, map to Free Fallback as it's the primary Safety Net
     const config = loadConfig();
-    if (mode === 'economy' && model) {
-        saveConfig({
-            fallbacks: { ...config.fallbacks, economy: model }
-        });
-        return {
-            handled: true,
-            response: `✅ Fallback Economy configuré: ${model}`
-        };
-    }
-    if (mode === 'pro' && model) {
-        saveConfig({
-            fallbacks: { ...config.fallbacks, pro: model }
-        });
-        return {
-            handled: true,
-            response: `✅ Fallback Pro configuré: ${model}`
-        };
-    }
+    saveConfig({
+        fallbacks: {
+            ...config.fallbacks,
+            free: {
+                main: main,
+                agent: agent || config.fallbacks.free.agent
+            }
+        }
+    });
     return {
         handled: true,
-        error: `Usage: /pollinations fallback [economy|pro] <modèle>`
+        response: `✅ Fallback (Free) configuré: main=${main}, agent=${agent || config.fallbacks.free.agent}`
     };
 }
 async function handleConnectCommand(args) {
@@ -307,15 +321,16 @@ 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.
+            saveKeyToAuthJson(key); // NATIVE SYNC: Hot-reload on OpenCode bypasses restart requirement !
             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;
@@ -340,10 +355,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! (Injection à chaud)**\n- Clé: \`${masked}\`\n- Modèles Pro Débloqués: ${enterpriseModels.length} (dont ${diamondCount} 💎 Paid)${forcedModeMsg}`
             };
         }
         else {
@@ -355,8 +370,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) {
@@ -373,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) {
@@ -415,65 +460,349 @@ function handleConfigCommand(args) {
         saveConfig({ thresholds: { ...config.thresholds, tier: threshold } });
         return { handled: true, response: `✅ threshold_tier = ${threshold}%` };
     }
-    if (key === 'threshold_wallet_warn' && value) {
+    if (key === 'threshold_wallet' && value) {
         const threshold = parseInt(value);
         if (isNaN(threshold) || threshold < 0 || threshold > 100) {
             return { handled: true, error: 'Valeur entre 0 et 100 requise' };
         }
         const config = loadConfig();
-        saveConfig({ thresholds: { ...config.thresholds, wallet_warn: threshold } });
-        return { handled: true, response: `✅ threshold_wallet_warn = ${threshold}%` };
-    }
-    if (key === 'threshold_wallet_stop' && value) {
-        const stopValue = parseFloat(value);
-        if (isNaN(stopValue) || stopValue < 0) {
-            return { handled: true, error: 'Valeur $ positive requise' };
-        }
-        const config = loadConfig();
-        saveConfig({ thresholds: { ...config.thresholds, wallet_stop: stopValue } });
-        return { handled: true, response: `✅ threshold_wallet_stop = $${stopValue}` };
+        saveConfig({ thresholds: { ...config.thresholds, wallet: threshold } });
+        return { handled: true, response: `✅ threshold_wallet = ${threshold}%` };
     }
     if (key === 'status_bar' && value) {
         const enabled = value === 'true';
         saveConfig({ statusBar: enabled });
         return { handled: true, response: `✅ status_bar = ${enabled}` };
     }
+    if (key === 'cost_estimator' && value) {
+        const enabled = value === 'true';
+        const config = loadConfig();
+        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_warn, threshold_wallet_stop, status_bar`
+        error: `Clé inconnue: ${key}. Clés: status_gui, logs_gui, threshold_tier, threshold_wallet, status_bar, cost_estimator, enablePaidTools, costThreshold, costConfirmation`
     };
 }
 function handleHelpCommand() {
     const help = `
-### 🌸 Pollinations Plugin - Commandes V6 (Economy/Pro)
+### 🌸 Pollinations Plugin - Commandes V6
 
-- **\`/pollinations mode [mode]\`**: Change le mode (economy, pro, manual).
+**Mode & Usage**
+- **\`/pollinations mode [mode]\`**: Change le mode (manual, alwaysfree, pro).
 - **\`/pollinations usage [full]\`**: Affiche le dashboard (full = détail).
-- **\`/pollinations fallback [mode] [model]\`**: Configure le Safety Net pour economy/pro.
+- **\`/pollinations fallback <main> [agent]\`**: Configure le Safety Net.
+
+**Configuration**
 - **\`/pollinations config [key] [value]\`**:
-  - \`threshold_tier\`: 0-100 (% Alerte Tier).
-  - \`threshold_wallet_warn\`: 0-100 (% Alerte Wallet Session).
-  - \`threshold_wallet_stop\`: Montage absolu $ (Stop Wallet).
-  - \`status_gui\`: none, alert, all.
-  - \`logs_gui\`: none, error, verbose.
-  - \`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
+  - \`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 {
         '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'); // Return help message
+            }
+            else if (cmd === 'pollinations.usage') {
+                const res = await handleCommand('usage');
+                if (res.response)
+                    globalClient?.tui.showToast({ title: "Pollinations Usage", metadata: { type: 'info', message: "Voir logs pour usage détaillé" } });
+            }
+            else if (cmd === 'pollinations.mode') {
+                // UI Pollution Fix: SILENCE.
+                // User explicitly requested NO messages.
+            }
         }
     };
 }