opencode-pollinations-plugin 6.1.0-beta.9 → 6.2.1

package/dist/server/commands.js

@@ -1,9 +1,10 @@
 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, getAggregatedModels } from './pollinations-api.js';
 import { generatePollinationsConfig } from './generate-config.js';
+import { ModelRegistry } from './models/index.js';
+import { t } from '../locales/index.js';
 function checkEndpoint(ep, key) {
     return new Promise((resolve) => {
         const req = https.request({
@@ -45,18 +46,16 @@ function checkEndpoint(ep, key) {
     });
 }
 export async function checkKeyPermissions(key) {
-    // SEQUENTIAL CHECK (Avoid Rate Limits on Key Verification)
-    const endpoints = ['/account/profile', '/account/balance', '/account/usage'];
-    for (const ep of endpoints) {
-        const res = await checkEndpoint(ep, key);
-        if (!res.ok) {
-            return { ok: false, reason: `${ep} (${res.status})` };
-        }
+    // SINGLE CHECK to reduce latency and avoid rate-limits (HIGH-01)
+    const res = await checkEndpoint('/account/profile', key);
+    if (!res.ok) {
+        return { ok: false, reason: `/account/profile (${res.status})` };
     }
     return { ok: true };
 }
 // === CONSTANTS & PRICING ===
 const TIER_LIMITS = {
+    microbe: { pollen: 0.1, emoji: '🦠' },
     spore: { pollen: 1, emoji: '🦠' },
     seed: { pollen: 3, emoji: '🌱' },
     flower: { pollen: 10, emoji: '🌸' },
@@ -130,6 +129,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')) {
@@ -145,48 +148,59 @@ export async function handleCommand(command) {
         case 'connect':
             return await handleConnectCommand(args);
         case 'fallback':
-            return await handleFallbackCommand(args);
+            return handleFallbackCommand(args);
         case 'config':
             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: t('commands.generic.add_key_hint')
+            };
         default:
             return {
                 handled: true,
-                error: `Commande inconnue: ${subCommand}. Utilisez /pollinations help`
+                response: t('commands.generic.unknown_command', { cmd: subCommand })
             };
     }
 }
 // === SUB-COMMANDS ===
 async function handleModeCommand(args) {
-    let mode = args[0];
+    const mode = args[0];
     if (!mode) {
         const config = loadConfig();
         return {
             handled: true,
-            response: `Mode actuel: ${config.mode}`
+            response: t('commands.mode.current', { mode: config.mode })
         };
     }
-    if (mode === 'alwaysfree')
-        mode = 'economy'; // Alias support
-    if (!['manual', 'economy', 'pro'].includes(mode)) {
+    if (!['manual', 'alwaysfree', 'pro'].includes(mode)) {
         return {
             handled: true,
-            error: `❌ Mode invalide: ${mode}. Valeurs: manual, economy, pro`
+            error: t('commands.mode.invalid', { mode })
         };
     }
     const checkConfig = loadConfig();
-    // JIT VERIFICATION for PRO and ECONOMY Mode
-    if (mode === 'pro' || mode === 'economy') {
+    // JIT VERIFICATION for PRO and ALWAYSFREE Mode
+    if (mode === 'pro' || mode === 'alwaysfree') {
         const checkConfig = loadConfig(); // Reload to be sure
         const key = checkConfig.apiKey;
         if (!key) {
             // If NO key, allow alwaysfree? Yes.
             // If HAS key, verify it? Yes.
             if (mode === 'pro')
-                return { handled: true, error: "❌ Mode Pro nécessite une Clé API configurée." };
+                return { handled: true, error: t('commands.mode.pro_requires_key') };
         }
-        emitStatusToast('info', 'Vérification des droits...', 'Mode Pro');
+        emitStatusToast('info', t('commands.mode.verifying'), 'Mode Pro');
         try {
             // Force verify permissions NOW
             const check = await checkKeyPermissions(key);
@@ -194,28 +208,28 @@ async function handleModeCommand(args) {
                 saveConfig({ mode: 'manual', keyHasAccessToProfile: false });
                 return {
                     handled: true,
-                    error: `❌ **Mode Refusé**\nVotre clé est limitée (Code ${check.status}: ${check.reason}).\nPassage en mode **manual**.`
+                    error: t('commands.mode.denied', { status: check.status || '?', reason: check.reason || '?' })
                 };
             }
             // Valid -> Ensure flag is true
             saveConfig({ keyHasAccessToProfile: true });
         }
         catch (e) {
-            return { handled: true, error: `❌ Erreur de vérification: ${e.message}` };
+            return { handled: true, error: t('commands.mode.verify_error', { error: 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') {
-        emitStatusToast('success', `Mode changé vers: ${mode}`, 'Pollinations Config');
+        emitStatusToast('success', t('commands.mode.success', { mode }), 'Pollinations Config');
     }
     return {
         handled: true,
-        response: `✅ Mode changé: ${mode}`
+        response: t('commands.mode.success', { mode })
     };
 }
-async function handleUsageCommand(args) {
+export async function handleUsageCommand(args) {
     const isFull = args[0] === 'full';
     try {
         const quota = await getQuotaStatus(true);
@@ -223,41 +237,41 @@ async function handleUsageCommand(args) {
         const resetDate = quota.nextResetAt.toLocaleString('fr-FR', { hour: '2-digit', minute: '2-digit' });
         const timeUntilReset = quota.nextResetAt.getTime() - Date.now();
         const durationStr = formatDuration(Math.max(0, timeUntilReset));
-        let response = `### 🌸 Dashboard Pollinations (${config.mode.toUpperCase()})\n\n`;
-        response += `**Ressources**\n`;
-        response += `- **Tier**: ${quota.tierEmoji} ${quota.tier.toUpperCase()} (${quota.tierLimit} pollen/jour)\n`;
-        response += `- **Quota**: ${formatPollen(quota.tierLimit - quota.tierRemaining)} / ${formatPollen(quota.tierLimit)}\n`;
-        response += `- **Usage**: ${progressBar(quota.tierLimit - quota.tierRemaining, quota.tierLimit)}\n`;
-        response += `- **Wallet**: $${quota.walletBalance.toFixed(2)}\n`;
-        response += `- **Reset**: ${resetDate} (dans ${durationStr})\n`;
+        let response = t('commands.usage.title', { mode: config.mode.toUpperCase() });
+        response += t('commands.usage.resources');
+        response += t('commands.usage.tier', { emoji: quota.tierEmoji, tier: quota.tier.toUpperCase(), limit: quota.tierLimit });
+        response += t('commands.usage.quota', { remaining: formatPollen(quota.tierLimit - quota.tierRemaining), limit: formatPollen(quota.tierLimit) });
+        response += t('commands.usage.usage_bar', { bar: progressBar(quota.tierLimit - quota.tierRemaining, quota.tierLimit) });
+        response += t('commands.usage.wallet', { balance: quota.walletBalance.toFixed(2) });
+        response += t('commands.usage.reset', { date: resetDate, duration: durationStr });
         if (isFull && config.apiKey) {
             if (config.keyHasAccessToProfile === false) {
-                response += `\n> ⚠️ *Votre clé API ne permet pas l'accès aux détails d'usage (Restriction).*`;
+                response += t('commands.usage.restricted_key');
             }
             else {
-                const usageData = await getDetailedUsage(config.apiKey);
-                if (usageData && usageData.usage) {
-                    const lastReset = calculateResetDate(quota.nextResetAt);
-                    const stats = calculateCurrentPeriodStats(usageData.usage, 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`;
-                    response += `| :--- | :---: | :---: | :---: |\n`;
+                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 += t('commands.usage.period_detail', { time: lastReset.toLocaleTimeString() });
+                    response += t('commands.usage.total_reqs', { reqs: stats.totalRequests, inTok: formatTokens(stats.inputTokens), outTok: formatTokens(stats.outputTokens) });
+                    response += t('commands.usage.table_head1');
+                    response += t('commands.usage.table_head2');
                     const sorted = Array.from(stats.models.entries()).sort((a, b) => b[1].cost - a[1].cost);
                     for (const [model, data] of sorted) {
                         response += `| \`${model}\` | ${data.requests} | ${formatPollen(data.cost)} | ${formatTokens(data.inputTokens + data.outputTokens)} |\n`;
                     }
                 }
                 else {
-                    response += `\n> ⚠️ *Impossible de récupérer l'historique détaillé.*\n`;
+                    response += t('commands.usage.no_history');
                 }
             }
         }
         else if (isFull) {
-            response += `\n> ⚠️ *Mode Full nécessite une API Key.*\n`;
+            response += t('commands.usage.full_requires_key');
         }
         else {
-            response += `\n_Tapez_ \`/pollinations usage full\` _pour le détail._\n`;
+            response += t('commands.usage.hint_full');
         }
         return { handled: true, response: response.trim() };
     }
@@ -265,44 +279,33 @@ async function handleUsageCommand(args) {
         return { handled: true, error: `Erreur: ${e}` };
     }
 }
-async function handleFallbackCommand(args) {
-    let targetMode = args[0];
-    const targetModel = args[1];
-    if (!targetMode || !targetModel) {
+function handleFallbackCommand(args) {
+    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,
-            error: `Usage: /pollinations fallback [economy|pro] <modèle>`
+            response: t('commands.fallback.current', { free: freeConfig, enter: enterConfig })
         };
     }
-    // Alias support
-    if (targetMode === 'alwaysfree')
-        targetMode = 'economy';
-    if (targetMode !== 'economy' && targetMode !== 'pro') {
-        return { handled: true, error: 'Target mode invalide (economy ou pro)' };
-    }
-    // DYNAMIC MODEL VALIDATION (BUG 2 FIX)
-    try {
-        const { data: models } = await getAggregatedModels();
-        const validIds = models.map(m => m.id.replace(/^pollinations\/(free|enter)\//, ''));
-        if (!validIds.includes(targetModel)) {
-            const suggestions = validIds.slice(0, 10).join(', ');
-            return {
-                handled: true,
-                error: `⚠️ Modèle inconnu: "${targetModel}".\nExemples valides: ${suggestions}...`
-            };
-        }
-    }
-    catch (e) {
-        // Fail-open si API down
-        console.warn('[Fallback] Model validation failed, allowing:', e);
-    }
+    // 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();
-    const updates = { fallbacks: { ...config.fallbacks } };
-    updates.fallbacks[targetMode] = targetModel;
-    saveConfig(updates);
+    saveConfig({
+        fallbacks: {
+            ...config.fallbacks,
+            free: {
+                main: main,
+                agent: agent || config.fallbacks.free.agent
+            }
+        }
+    });
     return {
         handled: true,
-        response: `✅ Fallback ${targetMode.charAt(0).toUpperCase() + targetMode.slice(1)} configuré: ${targetModel}`
+        response: t('commands.fallback.success', { main, agent: agent || config.fallbacks.free.agent })
     };
 }
 async function handleConnectCommand(args) {
@@ -310,21 +313,22 @@ async function handleConnectCommand(args) {
     if (!key) {
         return {
             handled: true,
-            error: `Utilisation: /pollinations connect <votre_clé_api>`
+            error: t('commands.connect.usage')
         };
     }
     // 1. Universal Validation (No Syntax Check) - Functional Check
-    emitStatusToast('info', 'Vérification de la clé...', 'Pollinations Config');
+    emitStatusToast('info', t('commands.connect.verifying'), '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;
@@ -344,15 +348,15 @@ async function handleConnectCommand(args) {
             // If Limited -> FORCE MANUAL
             if (isLimited) {
                 saveConfig({ apiKey: key, mode: 'manual', keyHasAccessToProfile: false });
-                forcedModeMsg = `\n⚠️ **Clé Limitée** (Echec: ${limitReason}) -> Mode **MANUEL** forcé.\n*Requis pour mode Auto: Profile, Balance & Usage.*`;
+                forcedModeMsg = t('commands.connect.limited', { reason: limitReason });
             }
             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', t('commands.connect.success_toast', { count: enterpriseModels.length }), '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: t('commands.connect.success_response', { key: masked, count: enterpriseModels.length, diamond: diamondCount, forced_msg: forcedModeMsg })
             };
         }
         else {
@@ -364,17 +368,27 @@ 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(t('proxy.errors.key_rejected'));
+            }
+            // If we are here, we got no enter models, or empty list?
+            // If key is valid but has no access?
+            throw new Error(t('proxy.errors.no_enter_models'));
         }
     }
     catch (e) {
         // 3. FAILURE HANDLING - Revert to FREE
         saveConfig({ apiKey: undefined, mode: 'manual' }); // Clear Key, Set Manual
-        emitStatusToast('error', `Clé Invalide. Retour au mode Gratuit.`, 'Pollinations Config');
+        emitStatusToast('error', t('toasts.invalid_key_revert'), 'Pollinations Config');
         return {
             handled: true,
-            error: `❌ **Échec Connexion**: ${e.message || e}\n\nLa configuration a été réinitialisée (Mode Gratuit/Manuel).`
+            error: t('proxy.errors.invalid_key_free_mode', { error: e.message || String(e) })
         };
     }
 }
@@ -382,11 +396,40 @@ 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)}` : '****') : t('commands.config.not_configured');
+        const markdownResponse = `${t('commands.config.title', { version: config.version || 'inconnue' })}
+${t('commands.config.alias_note')}
+${t('commands.config.intro')}
+
+${t('commands.config.table_headers')}
+${t('commands.config.table_divider')}
+| **apiKey** | \`${k}\` | ${t('commands.config.api_key_role')} | \`/poll connect <key>\` |
+| **mode** | \`${config.mode}\` | ${t('commands.config.mode_role')} | \`/poll mode <manual/pro/alwaysfree>\` |
+| **enablePaidTools**| \`${config.enablePaidTools ?? true}\` | ${t('commands.config.enablePaidTools_role')} | \`/poll config enablePaidTools <true/false>\` |
+| **costConfirmationRequired**| \`${config.costConfirmationRequired ?? true}\` | ${t('commands.config.costConfirmationRequired_role')} | \`/poll config costConfirmationRequired <true/false>\` |
+| **costThreshold**| \`${config.costThreshold ?? 0.15} 🌻\` | ${t('commands.config.costThreshold_role')} | \`/poll config costThreshold <X>\` |
+| **cost_estimator**| \`${config.costEstimator ?? true}\` | ${t('commands.config.cost_estimator_role')} | \`/poll config cost_estimator <true/false>\` |
+| **fallbacks.free.main** | \`${config.fallbacks?.free?.main || 'free/mistral'}\` | ${t('commands.config.fallback_main_role')} | \`/poll fallback <main> <agent>\` |
+| **fallbacks.free.agent** | \`${config.fallbacks?.free?.agent || 'free/openai-fast'}\`| ${t('commands.config.fallback_agent_role')} | \`/poll fallback <main> <agent>\` |
+| **fallbacks.enter.agent** | \`${config.fallbacks?.enter?.agent || 'free/openai-fast'}\`| ${t('commands.config.fallback_enter_role')} | *${t('commands.config.managed_auto')}* |
+| **status_gui** | \`${config.gui?.status || 'all'}\` | ${t('commands.config.status_gui_role')} | \`/poll config status_gui <all/alert/none>\` |
+| **logs_gui** | \`${config.gui?.logs || 'error'}\` | ${t('commands.config.logs_gui_role')} | \`/poll config logs_gui <verbose/error/none>\` |
+| **threshold_tier** | \`${config.thresholds?.tier || 80}%\` | ${t('commands.config.threshold_tier_role')} | \`/poll config threshold_tier <1-100>\` |
+| **threshold_wallet** | \`${config.thresholds?.wallet || 80}%\` | ${t('commands.config.threshold_wallet_role')} | \`/poll config threshold_wallet <1-100>\` |
+| **status_bar** | \`${config.statusBar ?? true}\` | ${t('commands.config.status_bar_role')} | \`/poll config status_bar <true/false>\` |
+| **lang** | \`${config.lang || 'en'}\` | ${t('commands.config.lang_role')} | \`/poll config lang <en/fr/es/de/it>\` |`;
         return {
             handled: true,
-            response: JSON.stringify(config, null, 2)
+            response: markdownResponse
         };
     }
+    if (key === 'lang' && value) {
+        if (!['en', 'fr', 'es', 'de', 'it'].includes(value)) {
+            return { handled: true, error: "Valeurs supportées: en, fr, es, de, it" };
+        }
+        saveConfig({ lang: value });
+        return { handled: true, response: `✅ lang = ${value} (redémarrage recommandé)` };
+    }
     if (key === 'toast_verbosity' && value) {
         // BACKWARD COMPAT (Maps to Status GUI)
         if (!['none', 'alert', 'all'].includes(value)) {
@@ -424,65 +467,291 @@ 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 === 'costConfirmationRequired' && 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, costConfirmationRequired, lang`
     };
 }
 function handleHelpCommand() {
     const help = `
-### 🌸 Pollinations Plugin - Commandes V6 (Economy/Pro)
+${t('commands.help.title')}
+${t('commands.help.alias_note')}
+
+${t('commands.help.mode_usage')}
+
+${t('commands.help.configuration')}
 
-- **\`/pollinations mode [mode]\`**: Change le mode (economy, pro, manual).
-- **\`/pollinations usage [full]\`**: Affiche le dashboard (full = détail).
-- **\`/pollinations fallback [mode] [model]\`**: Configure le Safety Net pour economy/pro.
-- **\`/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).
+${t('commands.help.models_pricing')}
 `.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: t('commands.models.loading')
+        };
+    }
+    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(t('commands.models.free_title'));
+                sections.push(t('commands.models.free_desc'));
+                sections.push(t('commands.models.free_headers1'));
+                sections.push(t('commands.models.free_headers2'));
+                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(t('commands.models.free_error'));
+        }
+    }
+    sections.push(t('commands.models.enter_title'));
+    const categories = [
+        { cat: 'image', emoji: '🎨', label: t('commands.models.cats.image') },
+        { cat: 'video', emoji: '🎬', label: t('commands.models.cats.video') },
+        { cat: 'audio', emoji: '🔊', label: t('commands.models.cats.audio') },
+        { cat: 'text', emoji: '📝', label: t('commands.models.cats.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(t('commands.models.cat_title', { emoji, label, count: models.length }));
+        sections.push(t('commands.models.enter_headers1'));
+        sections.push(t('commands.models.enter_headers2'));
+        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(t('commands.models.capabilities'));
+    sections.push(t('commands.models.other'));
+    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;
+    const tokens = t('commands.pricing_units.tokens');
+    const s = t('commands.pricing_units.s');
+    const img = t('commands.pricing_units.img');
+    const tok = t('commands.pricing_units.tok');
+    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 = `${t('commands.infos.title', { name })}
+${t('commands.infos.features_title')}
+${t('commands.infos.features_free')}
+
+${t('commands.infos.features_pro')}
+
+${t('commands.infos.features_config')}
+
+${t('commands.infos.tiers_title', { emoji: tierEmoji, tier: tier.toUpperCase() })}
+${t('commands.infos.about')}
+
+${t('commands.infos.levels_title')}
+${t('commands.infos.levels_list')}
+
+${t('commands.infos.beta_note')}
+
+${t('commands.infos.pollen_title')}
+
+${t('commands.infos.pollen_get')}
+
+${t('commands.infos.pollen_spend')}`;
+    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 = t('commands.generic.tui_error', { error: 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 = t('commands.generic.tui_critical', { error: 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: t('commands.generic.tui_usage_msg') } });
+            }
+            else if (cmd === 'pollinations.mode') {
+                // UI Pollution Fix: SILENCE.
+                // User explicitly requested NO messages.
+            }
         }
     };
 }