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

package/dist/tools/pollinations/gen_image.js

@@ -1,66 +1,34 @@
 /**
  * gen_image Tool - Pollinations Image Generation
  *
- * Updated: 2026-02-12 - Verified API Reference
+ * Updated: 2026-02-19 - Dynamic ModelRegistry + Cost Guard + Toasts
  *
- * Supports:
- * - FREE models: sana, zimage (flux REMOVED, turbo BROKEN)
- * - ENTER models: flux, kontext, seedream, klein, gptimage, imagen-4, etc.
- * - Image-to-Image (I2I): klein, klein-large, kontext, seedream, seedream-pro, nanobanana, nanobanana-pro
- * - Multi-image I2I: seedream-pro (comma-separated URLs)
+ * All models are dynamic from the Pollinations API.
+ * Unknown models are accepted as (beta) and passed through to the API.
+ * Cost Guard reads enablePaidTools, costConfirmationRequired, costThreshold.
  */
 import { tool } from '@opencode-ai/plugin/tool';
 import * as fs from 'fs';
 import * as path from 'path';
-import { getApiKey, hasApiKey, httpsGet, ensureDir, generateFilename, getDefaultOutputDir, formatCost, formatFileSize, estimateImageCost, isCostEstimatorEnabled, supportsI2I, FREE_IMAGE_MODELS, PAID_IMAGE_MODELS, } from './shared.js';
+import { getApiKey, hasApiKey, httpsGet, ensureDir, generateFilename, getDefaultOutputDir, formatCost, formatFileSize, estimateImageCost, extractCostFromHeaders, isCostEstimatorEnabled, supportsI2I, getPaidImageModels, fetchEnterBalance, } from './shared.js';
+import { loadConfig } from '../../server/config.js';
+import { checkCostControl, isTokenBased } from './cost-guard.js';
+import { emitStatusToast } from '../../server/toast.js';
 // ─── Constants ─────────────────────────────────────────────────────────────
-/**
- * FREE models that work reliably (2026-02-12)
- * WARNING: flux removed from free, turbo shows deprecated notice
- */
-const RELIABLE_FREE_MODELS = ['sana', 'zimage'];
 const DEFAULT_MODEL = 'flux';
-const FREE_DEFAULT_MODEL = 'sana';
 // ─── Tool Definition ──────────────────────────────────────────────────────
-export const genImageTool = tool({
+export const polliGenImageTool = tool({
     description: `Generate an image from a text prompt using Pollinations AI.
 
-**🆓 FREE Models** (no API key, no cost):
-- \`sana\`: Default free model (~60KB, reliable)
-- \`zimage\`: Low quality alias (~35KB)
-- ⚠️ \`turbo\`: BROKEN - shows deprecated notice
-- ⚠️ \`flux\`: REMOVED from free tier!
-
-**💎 ENTER Models** (requires API key):
-| Model | Cost | T2I | I2I | Notes |
-|-------|------|-----|-----|-------|
-| flux | 0.0002 🌻 | ✅ | ❌ | Fast high-quality |
-| zimage | 0.0002 🌻 | ✅ | ❌ | 6B Flux with 2x upscaling |
-| imagen-4 | 0.0025 🌻 | ✅ | ❌ | Google high fidelity |
-| klein | 0.008 🌻 | ✅ | ✅ | FLUX.2 Klein 4B |
-| klein-large | 0.012 🌻 | ✅ | ✅ | FLUX.2 Klein 9B |
-| kontext | 0.04 🌻 | ✅ | ✅ | In-Context Editing |
-| seedream | 0.03 🌻 | ✅ | ✅ | ByteDance ARK quality |
-| seedream-pro | 0.04 🌻 | ✅ | ✅ | 4K, Multi-Image support |
-| gptimage | tokens | ✅ | ❌ | OpenAI GPT Image Mini |
-| gptimage-large | tokens | ✅ | ❌ | OpenAI GPT Image 1.5 |
-| nanobanana | tokens | ✅ | ✅ | Gemini 2.5 Flash |
-| nanobanana-pro | tokens | ✅ | ✅ | Gemini 3 Pro Thinking |
-
-**🖼️ Image-to-Image (I2I)**:
-Models with I2I support can transform existing images.
-- Use \`reference_image\` parameter with URL or local path
-- \`seedream-pro\` supports multiple images (comma-separated URLs)
-- \`kontext\` specializes in in-context editing
+💡 **Modèles Image Dynamiques** :
+L'API Pollinations (Enter) possède une quantité importante de modèles (Flux, Midjourney, Seedream, etc.) et ils changent fréquemment. Le catalogue à jour est listé ci-dessous.
 
-**⚙️ Per-Model Parameters**:
-- \`width/height\`: All models (default: 1024x1024)
-- \`quality\`: gptimage only (low/med/high)
-- \`transparent\`: gptimage only (true/false)
-- \`seed\`: Reproducibility (-1 for random)`,
+**Exemples d'utilisation Optionnelle** :
+- **I2I (Image-to-Image)** : Utilisez le paramètre \`reference_image\` avec une URL ou chemin local si le modèle le supporte.
+- L'outil embarque un "costGuard" automatique gérant la confirmation des coûts.`,
     args: {
         prompt: tool.schema.string().describe('Description of the image to generate'),
-        model: tool.schema.string().optional().describe('Model to use (default: flux or sana if no key)'),
+        model: tool.schema.string().optional().describe('Model to use (default: flux). Unknown models accepted as (beta).'),
         width: tool.schema.number().min(256).max(4096).optional().describe('Image width (default: 1024)'),
         height: tool.schema.number().min(256).max(4096).optional().describe('Image height (default: 1024)'),
         reference_image: tool.schema.string().optional().describe('URL(s) for image-to-image editing (comma-separated for multi-image models)'),
@@ -74,156 +42,174 @@ Models with I2I support can transform existing images.
         const apiKey = getApiKey();
         const hasKey = hasApiKey();
         // Determine model based on key presence
-        let model = args.model || (hasKey ? DEFAULT_MODEL : FREE_DEFAULT_MODEL);
+        let model = args.model || DEFAULT_MODEL;
         const width = args.width || 1024;
         const height = args.height || 1024;
-        // Check if it's a free model
-        const isFreeModel = Object.keys(FREE_IMAGE_MODELS).includes(model);
-        const isReliableFree = RELIABLE_FREE_MODELS.includes(model);
-        // Check if it's a paid model
-        const paidModelInfo = PAID_IMAGE_MODELS[model];
-        const isPaidModel = !!paidModelInfo;
-        // Validate model selection
-        if (isFreeModel && !isReliableFree) {
-            return `⚠️ Le modèle "${model}" n'est plus fiable.
-${model === 'turbo' ? '`turbo` affiche une notice de dépréciation.' : ''}
-💡 Modèles gratuits recommandés: ${RELIABLE_FREE_MODELS.join(', ')}
-${hasKey ? `💎 Ou utilisez un modèle payant: flux, kontext, seedream...` : ''}`;
+        // Fetch known models from registry
+        const imageModels = getPaidImageModels();
+        const knownModel = !!imageModels[model];
+        const isBetaModel = !knownModel;
+        // Force Auth Check for ALL Image Generations
+        if (!hasKey) {
+            return `❌ **Clé API Requise** pour la génération d'images.
+💡 Utilisez \`/pollinations connect <clé>\` pour activer le service.
+💎 Modèles disponibles: ${Object.keys(imageModels).slice(0, 5).join(', ')}...`;
         }
-        if (isPaidModel && !hasKey) {
-            return `❌ Le modèle "${model}" nécessite une clé API.
-💡 Utilisez un modèle gratuit: ${RELIABLE_FREE_MODELS.join(', ')}
-🔧 Ou connectez votre clé avec /pollinations connect`;
+        // Unknown model → beta passthrough (don't reject)
+        if (isBetaModel) {
+            emitStatusToast('warning', `Modèle "${model}" non référencé — mode (beta)`, '🎨 gen_image');
         }
-        // Validate I2I support
-        if (args.reference_image && isPaidModel && !supportsI2I(model)) {
+        // Validate I2I support (for known models only; beta models get default behavior)
+        if (args.reference_image && knownModel && !supportsI2I(model)) {
             return `⚠️ Le modèle "${model}" ne supporte pas l'Image-to-Image.
-💡 Modèles I2I supportés: ${Object.entries(PAID_IMAGE_MODELS)
+💡 Modèles I2I supportés: ${Object.entries(imageModels)
                 .filter(([, info]) => info.i2i)
                 .map(([name]) => name)
                 .join(', ')}`;
         }
-        // Check if model exists
-        if (!isFreeModel && !isPaidModel) {
-            return `❌ Modèle inconnu: ${model}
-💡 Modèles gratuits: ${RELIABLE_FREE_MODELS.join(', ')}
-💎 Modèles payants: ${Object.keys(PAID_IMAGE_MODELS).slice(0, 5).join(', ')}...`;
-        }
         // Estimate cost
-        const estimatedCost = isPaidModel ? estimateImageCost(model) : 0;
+        const estimatedCost = estimateImageCost(model);
+        // Cost Guard check V2
+        const costCheck = checkCostControl('polli_gen_image', args, model, estimatedCost, 'image');
+        if (!costCheck.allowed) {
+            return costCheck.message || '❌ Opération bloquée par le Cost Guard.';
+        }
+        // Emit start toast
+        const config = loadConfig();
+        const argsStr = config.gui?.logs === 'verbose' ? `\nParameters: ${JSON.stringify(args)}` : '';
+        emitStatusToast('info', `Génération image: ${model} (${width}×${height})${argsStr}`, '🎨 polli_gen_image');
         // Set metadata
-        context.metadata({ title: `🎨 Image: ${model}` });
+        context.metadata({ title: `🎨 Image: ${model}${isBetaModel ? ' (beta)' : ''}` });
         try {
             let imageData;
             let responseHeaders = {};
             let usedModel = model;
-            if (isFreeModel && !hasKey) {
-                // === FREE endpoint (image.pollinations.ai) ===
-                const params = new URLSearchParams({
-                    nologo: 'true',
-                    private: 'true',
-                });
-                if (model !== 'sana') {
-                    params.set('model', model);
-                }
-                if (args.seed !== undefined) {
-                    params.set('seed', String(args.seed));
-                }
-                const promptEncoded = encodeURIComponent(args.prompt);
-                const url = `https://image.pollinations.ai/${promptEncoded}?${params}`;
-                const result = await httpsGet(url);
-                imageData = result.data;
+            // === ENTER endpoint ONLY (gen.pollinations.ai) ===
+            const params = new URLSearchParams({
+                nologo: 'true',
+                private: 'true',
+                width: String(width),
+                height: String(height),
+            });
+            // Model parameter
+            params.set('model', model);
+            // Seed
+            if (args.seed !== undefined) {
+                params.set('seed', String(args.seed));
             }
-            else {
-                // === ENTER endpoint (gen.pollinations.ai) ===
-                const params = new URLSearchParams({
-                    nologo: 'true',
-                    private: 'true',
-                    width: String(width),
-                    height: String(height),
-                });
-                // Model parameter
-                params.set('model', model);
-                // Seed
-                if (args.seed !== undefined) {
-                    params.set('seed', String(args.seed));
-                }
-                // I2I: reference image(s)
-                if (args.reference_image) {
-                    // Check if it's a local file path
-                    let imageUrl = args.reference_image;
-                    if (!args.reference_image.startsWith('http')) {
-                        // For local files, we'd need to upload first
-                        // For now, require URL
-                        return `❌ Les fichiers locaux nécessitent d'être uploadés d'abord.
+            // I2I: reference image(s)
+            if (args.reference_image) {
+                // Check if it's a local file path
+                let imageUrl = args.reference_image;
+                if (!args.reference_image.startsWith('http')) {
+                    // For local files, we'd need to upload first
+                    // For now, require URL
+                    return `❌ Les fichiers locaux nécessitent d'être uploadés d'abord.
 💡 Utilisez l'outil \`file_to_url\` pour obtenir une URL publique.`;
-                    }
-                    params.set('image', imageUrl);
-                }
-                // Quality (gptimage only)
-                if (args.quality && model.startsWith('gptimage')) {
-                    params.set('quality', args.quality);
                 }
-                // Transparent (gptimage only)
-                if (args.transparent !== undefined && model.startsWith('gptimage')) {
-                    params.set('transparent', String(args.transparent));
+                params.set('image', imageUrl);
+            }
+            // Quality (gptimage only)
+            if (args.quality && model.startsWith('gptimage')) {
+                params.set('quality', args.quality);
+            }
+            // Transparent (gptimage only)
+            if (args.transparent !== undefined && model.startsWith('gptimage')) {
+                params.set('transparent', String(args.transparent));
+            }
+            const promptEncoded = encodeURIComponent(args.prompt);
+            const url = `https://gen.pollinations.ai/image/${promptEncoded}?${params}`;
+            const headers = {};
+            if (apiKey)
+                headers['Authorization'] = `Bearer ${apiKey}`;
+            // 1. Fetch balance avant génération
+            const balBefore = await fetchEnterBalance();
+            const result = await httpsGet(url, headers);
+            imageData = result.data;
+            responseHeaders = result.headers;
+            // Update used model from response if available
+            if (responseHeaders['x-model-used']) {
+                usedModel = responseHeaders['x-model-used'];
+            }
+            // Save the image
+            let outputDir = getDefaultOutputDir('images');
+            let filename = args.filename;
+            if (args.save_to) {
+                if (args.save_to.match(/\.(png|jpe?g|webp|gif)$/i)) {
+                    outputDir = path.dirname(args.save_to);
+                    filename = path.basename(args.save_to);
                 }
-                const promptEncoded = encodeURIComponent(args.prompt);
-                const url = `https://gen.pollinations.ai/image/${promptEncoded}?${params}`;
-                const headers = {};
-                if (apiKey)
-                    headers['Authorization'] = `Bearer ${apiKey}`;
-                const result = await httpsGet(url, headers);
-                imageData = result.data;
-                responseHeaders = result.headers;
-                // Update used model from response if available
-                if (responseHeaders['x-model-used']) {
-                    usedModel = responseHeaders['x-model-used'];
+                else {
+                    outputDir = args.save_to;
                 }
             }
-            // Save the image
-            const outputDir = args.save_to || getDefaultOutputDir('images');
             ensureDir(outputDir);
-            const filename = args.filename || generateFilename('image', usedModel, 'png');
-            const filePath = path.join(outputDir, filename.endsWith('.png') ? filename : `${filename}.png`);
+            filename = filename || generateFilename('image', usedModel, 'png');
+            const filePath = path.join(outputDir, filename.includes('.') ? filename : `${filename}.png`);
             fs.writeFileSync(filePath, imageData);
-            const fileSize = fs.statSync(filePath).size;
-            // Extract actual cost from headers if available
-            let actualCost = estimatedCost;
-            if (isCostEstimatorEnabled() && responseHeaders['x-usage-completion-image-tokens']) {
-                const tokens = parseFloat(responseHeaders['x-usage-completion-image-tokens']);
-                // Token-based cost calculation would go here
+            // 2. Fetch balance après génération (delay for API sync)
+            let balAfter = null;
+            let realCost;
+            if (balBefore !== null) {
+                await new Promise(r => setTimeout(r, 1000)); // Laisse le temps au ledger
+                balAfter = await fetchEnterBalance();
+                if (balAfter !== null) {
+                    realCost = Math.round((balBefore - balAfter) * 10000) / 10000;
+                }
             }
+            // Extract cost from headers as fallback/info
+            const costTracking = extractCostFromHeaders(responseHeaders);
             // Build result
-            const lines = [
-                `🎨 Image Générée`,
-                `━━━━━━━━━━━━━━━━━━`,
-                `Prompt: ${args.prompt.substring(0, 100)}${args.prompt.length > 100 ? '...' : ''}`,
-                `Modèle: ${usedModel}${isFreeModel ? ' (GRATUIT)' : ''}`,
-                `Résolution: ${width}×${height}`,
-            ];
+            const fileSize = fs.statSync(filePath).size;
+            const lines = [];
+            // Inject costWarning at top if present
+            if (costCheck.message && !costCheck.allowed) { // Assuming costWarning should come from costCheck if not allowed
+                lines.push(costCheck.message);
+                lines.push('');
+            }
+            lines.push(`🎨 Image Générée`);
+            lines.push(`━━━━━━━━━━━━━━━━━━`);
+            lines.push(`Prompt: ${args.prompt.substring(0, 100)}${args.prompt.length > 100 ? '...' : ''}`);
+            lines.push(`Modèle: ${usedModel}${isBetaModel ? ' (beta)' : ''}`);
+            lines.push(`Résolution: ${width}×${height}`);
             // Add I2I info if used
             if (args.reference_image) {
                 lines.push(`I2I Source: ${args.reference_image.substring(0, 50)}...`);
             }
             lines.push(`Fichier: ${filePath}`);
             lines.push(`Taille: ${formatFileSize(fileSize)}`);
-            // Cost info
-            if (isFreeModel) {
-                lines.push(`Coût: GRATUIT`);
-            }
-            else {
-                lines.push(`Coût estimé: ${formatCost(actualCost)}`);
-                if (responseHeaders['x-request-id']) {
-                    lines.push(`Request ID: ${responseHeaders['x-request-id']}`);
+            // Pricing details (Estimé vs Réel)
+            if (isCostEstimatorEnabled()) {
+                const maxCost = estimatedCost * 3;
+                lines.push(`\n💰 **Rapport Financier :**`);
+                if (isTokenBased('image', usedModel)) {
+                    lines.push(`- Coût Estimé   : ${formatCost(estimatedCost)} (Max théorique: ${formatCost(maxCost)})`);
+                }
+                else {
+                    lines.push(`- Coût Estimé   : ${formatCost(estimatedCost)}`);
+                }
+                if (realCost !== undefined) {
+                    lines.push(`- Coût Réel     : **${formatCost(realCost)}** (via Solde Wallet)`);
                 }
+                else if (costTracking.costUsd !== undefined) {
+                    lines.push(`- Coût Réel     : **${formatCost(costTracking.costUsd)}** (via Headers API)`);
+                }
+                else {
+                    lines.push(`- Coût Réel     : Inconnu (API injoignable)`);
+                }
+            }
+            if (responseHeaders['x-request-id']) {
+                lines.push(`Request ID: ${responseHeaders['x-request-id']}`);
             }
+            // Emit success toast
+            emitStatusToast('success', `Image générée ✓ (${usedModel})`, '🎨 gen_image', { filePath: filePath });
             return lines.join('\n');
         }
         catch (err) {
+            emitStatusToast('error', `Erreur: ${err.message?.substring(0, 60)}`, '🎨 gen_image');
             if (err.message?.includes('402') || err.message?.includes('Payment')) {
-                return `❌ Crédits insuffisants pour le modèle "${model}".
-💡 Essayez un modèle gratuit: ${RELIABLE_FREE_MODELS.join(', ')}`;
+                return `❌ Crédits pollen insuffisants pour le modèle "${model}".
+💡 Vérifiez votre solde avec /pollinations usage`;
             }
             if (err.message?.includes('401') || err.message?.includes('403')) {
                 return `❌ Clé API invalide ou non autorisée.

package/dist/tools/pollinations/gen_music.d.ts

@@ -11,4 +11,4 @@
  * - instrumental: boolean (vocals or instrumental only)
  */
 import { type ToolDefinition } from '@opencode-ai/plugin/tool';
-export declare const genMusicTool: ToolDefinition;
+export declare const polliGenMusicTool: ToolDefinition;

package/dist/tools/pollinations/gen_music.js

@@ -13,14 +13,17 @@
 import { tool } from '@opencode-ai/plugin/tool';
 import * as fs from 'fs';
 import * as path from 'path';
-import { getApiKey, httpsGet, ensureDir, generateFilename, getDefaultOutputDir, formatCost, formatFileSize, estimateMusicCost, isCostEstimatorEnabled, } from './shared.js';
+import { getApiKey, httpsGet, ensureDir, generateFilename, getDefaultOutputDir, formatCost, formatFileSize, estimateMusicCost, extractCostFromHeaders, isCostEstimatorEnabled, } from './shared.js';
+import { loadConfig } from '../../server/config.js';
+import { checkCostControl, isTokenBased } from './cost-guard.js';
+import { emitStatusToast } from '../../server/toast.js';
 // ─── Constants ─────────────────────────────────────────────────────────────
 const MIN_DURATION = 3;
 const MAX_DURATION = 300; // 5 minutes
 const DEFAULT_DURATION = 10;
 const MODEL_NAME = 'elevenmusic';
 // ─── Tool Definition ──────────────────────────────────────────────────────
-export const genMusicTool = tool({
+export const polliGenMusicTool = tool({
     description: `Generate music from a text description using Pollinations AI.
 
 **🎵 Model:** elevenmusic (ElevenLabs Music)
@@ -65,8 +68,17 @@ export const genMusicTool = tool({
         const instrumental = args.instrumental || false;
         // Estimate cost
         const estimatedCost = estimateMusicCost(duration);
+        // Cost Guard check V2
+        const costCheck = checkCostControl('polli_gen_music', args, MODEL_NAME, estimatedCost, 'audio');
+        if (!costCheck.allowed) {
+            return costCheck.message || '❌ Opération bloquée par le Cost Guard.';
+        }
         // Estimate generation time
-        const genTimeSeconds = Math.ceil(duration * 1.2); // ~1.2s per second of audio
+        const genTimeSeconds = Math.ceil(duration * 1.2);
+        // Emit start toast
+        const config = loadConfig();
+        const argsStr = config.gui?.logs === 'verbose' ? `\nParameters: ${JSON.stringify(args)}` : '';
+        emitStatusToast('info', `Génération musique: ${duration}s (~${genTimeSeconds}s gen)${argsStr}`, '🎵 polli_gen_music');
         // Metadata
         context.metadata({ title: `🎵 Music: ${duration}s (~${genTimeSeconds}s gen time)` });
         try {
@@ -94,25 +106,51 @@ export const genMusicTool = tool({
             const audioData = result.data;
             const responseHeaders = result.headers;
             // Save audio
-            const outputDir = args.save_to || getDefaultOutputDir('music');
+            let outputDir = getDefaultOutputDir('music');
+            let filename = args.filename;
+            if (args.save_to) {
+                if (args.save_to.match(/\.(mp3|wav|ogg|m4a)$/i)) {
+                    outputDir = path.dirname(args.save_to);
+                    filename = path.basename(args.save_to);
+                }
+                else {
+                    outputDir = args.save_to;
+                }
+            }
             ensureDir(outputDir);
-            const filename = args.filename || generateFilename('music', MODEL_NAME, 'mp3');
+            filename = filename || generateFilename('music', MODEL_NAME, 'mp3');
             const filePath = path.join(outputDir, filename.endsWith('.mp3') ? filename : `${filename}.mp3`);
             fs.writeFileSync(filePath, audioData);
             const fileSize = fs.statSync(filePath).size;
+            let actualCost = estimatedCost;
+            if (responseHeaders) {
+                const costTracking = extractCostFromHeaders(responseHeaders);
+                if (costTracking.costUsd !== undefined)
+                    actualCost = costTracking.costUsd;
+            }
             // Build result
-            const lines = [
-                `🎵 Musique Générée`,
-                `━━━━━━━━━━━━━━━━━━`,
-                `Prompt: ${args.prompt}`,
-                `Durée: ~${duration}s`,
-                `Mode: ${instrumental ? 'Instrumental (sans voix)' : 'Avec voix possible'}`,
-                `Fichier: ${filePath}`,
-                `Taille: ${formatFileSize(fileSize)}`,
-            ];
+            const lines = [];
+            // Inject costWarning at top if present
+            if (costCheck.message && !costCheck.allowed) {
+                lines.push(costCheck.message);
+                lines.push('');
+            }
+            lines.push(`🎵 Musique Générée`);
+            lines.push(`━━━━━━━━━━━━━━━━━━`);
+            lines.push(`Prompt: ${args.prompt}`);
+            lines.push(`Durée: ~${duration}s`);
+            lines.push(`Mode: ${instrumental ? 'Instrumental (sans voix)' : 'Avec voix possible'}`);
+            lines.push(`Fichier: ${filePath}`);
+            lines.push(`Taille: ${formatFileSize(fileSize)}`);
             // Cost info
             if (isCostEstimatorEnabled()) {
-                lines.push(`Coût estimé: ${formatCost(estimatedCost)}`);
+                if (isTokenBased('audio', MODEL_NAME)) {
+                    const maxCost = estimatedCost * 3;
+                    lines.push(`Coût: ${formatCost(actualCost)} (Max théorique: ${formatCost(maxCost)})`);
+                }
+                else {
+                    lines.push(`Coût: ${formatCost(actualCost)}`);
+                }
             }
             if (responseHeaders['x-model-used']) {
                 lines.push(`Modèle utilisé: ${responseHeaders['x-model-used']}`);
@@ -120,11 +158,14 @@ export const genMusicTool = tool({
             if (responseHeaders['x-request-id']) {
                 lines.push(`Request ID: ${responseHeaders['x-request-id']}`);
             }
+            // Emit success toast
+            emitStatusToast('success', `Musique générée ✓ (${duration}s)`, '🎵 gen_music');
             return lines.join('\n');
         }
         catch (err) {
+            emitStatusToast('error', `Erreur: ${err.message?.substring(0, 60)}`, '🎵 gen_music');
             if (err.message?.includes('402') || err.message?.includes('Payment')) {
-                return `❌ Crédits insuffisants.`;
+                return `❌ Crédits pollen insuffisants.`;
             }
             if (err.message?.includes('401') || err.message?.includes('403')) {
                 return `❌ Clé API invalide ou non autorisée.`;

package/dist/tools/pollinations/gen_video.d.ts

@@ -13,4 +13,4 @@
  * - x-usage-completion-video-tokens (seedance, seedance-pro)
  */
 import { type ToolDefinition } from '@opencode-ai/plugin/tool';
-export declare const genVideoTool: ToolDefinition;
+export declare const polliGenVideoTool: ToolDefinition;