opencode-pollinations-plugin 6.1.0-beta.1 → 6.1.0-beta.11

package/dist/tools/index.js

@@ -0,0 +1,81 @@
+/**
+ * Tool Registry — Conditional Injection System
+ *
+ * Free Universe (no key): 8 tools always available
+ * Enter Universe (with key): +6 Pollinations tools
+ *
+ * Tools are injected ONCE at plugin init. Restart needed after /poll connect.
+ */
+import { loadConfig } from '../server/config.js';
+// === FREE TOOLS (Always available) ===
+import { genQrcodeTool } from './design/gen_qrcode.js';
+import { genDiagramTool } from './design/gen_diagram.js';
+import { genPaletteTool } from './design/gen_palette.js';
+import { fileToUrlTool } from './power/file_to_url.js';
+import { removeBackgroundTool } from './power/remove_background.js';
+import { extractFramesTool } from './power/extract_frames.js';
+import { extractAudioTool } from './power/extract_audio.js';
+import { rmbgKeysTool } from './power/rmbg_keys.js';
+// === ENTER TOOLS (Require API key) ===
+import { genImageTool } from './pollinations/gen_image.js';
+import { genVideoTool } from './pollinations/gen_video.js';
+import { genAudioTool } from './pollinations/gen_audio.js';
+import { transcribeAudioTool } from './pollinations/transcribe_audio.js';
+import { genMusicTool } from './pollinations/gen_music.js';
+import { deepsearchTool } from './pollinations/deepsearch.js';
+import { searchCrawlScrapeTool } from './pollinations/search_crawl_scrape.js';
+import * as fs from 'fs';
+const LOG_FILE = '/tmp/opencode_pollinations_v4.log';
+function log(msg) {
+    try {
+        fs.appendFileSync(LOG_FILE, `[${new Date().toISOString()}] [Tools] ${msg}\n`);
+    }
+    catch { }
+}
+/**
+ * Detect if a valid API key is present
+ */
+function hasValidKey() {
+    const config = loadConfig();
+    return !!(config.apiKey && config.apiKey.length > 5 && config.apiKey !== 'dummy');
+}
+/**
+ * Build the tool registry based on user's access level
+ *
+ * @returns Record<string, Tool> to be spread into the plugin's tool: {} property
+ */
+export function createToolRegistry() {
+    const tools = {};
+    const keyPresent = hasValidKey();
+    // === FREE UNIVERSE: Always injected (8 tools) ===
+    // Design tools (3)
+    tools['gen_qrcode'] = genQrcodeTool;
+    tools['gen_diagram'] = genDiagramTool;
+    tools['gen_palette'] = genPaletteTool;
+    // Power tools (5)
+    tools['file_to_url'] = fileToUrlTool;
+    tools['remove_background'] = removeBackgroundTool;
+    tools['extract_frames'] = extractFramesTool;
+    tools['extract_audio'] = extractAudioTool;
+    tools['rmbg_keys'] = rmbgKeysTool;
+    log(`Free tools injected: ${Object.keys(tools).length}`);
+    // === ENTER UNIVERSE: Only with valid API key (+7 tools) ===
+    if (keyPresent) {
+        // Pollinations media tools
+        tools['gen_image'] = genImageTool;
+        tools['gen_video'] = genVideoTool;
+        tools['gen_audio'] = genAudioTool;
+        tools['transcribe_audio'] = transcribeAudioTool;
+        tools['gen_music'] = genMusicTool;
+        // Search tools
+        tools['deepsearch'] = deepsearchTool;
+        tools['search_crawl_scrape'] = searchCrawlScrapeTool;
+        log(`Enter tools injected (key detected). Total: ${Object.keys(tools).length}`);
+    }
+    else {
+        log(`Enter tools SKIPPED (no key). Total: ${Object.keys(tools).length}`);
+    }
+    return tools;
+}
+// Re-export for convenience
+export { genImageTool, genVideoTool, genAudioTool, transcribeAudioTool, genMusicTool, deepsearchTool, searchCrawlScrapeTool, };

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

@@ -0,0 +1,7 @@
+/**
+ * deepsearch Tool - Deep Research with AI
+ *
+ * Uses perplexity-reasoning for in-depth research and analysis
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const deepsearchTool: ToolDefinition;

package/dist/tools/pollinations/deepsearch.js

@@ -0,0 +1,80 @@
+/**
+ * deepsearch Tool - Deep Research with AI
+ *
+ * Uses perplexity-reasoning for in-depth research and analysis
+ */
+import { tool } from '@opencode-ai/plugin/tool';
+import { getApiKey, httpsPost, } from './shared.js';
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const deepsearchTool = tool({
+    description: `Perform deep research and analysis on a topic using AI reasoning.
+
+**Model:** perplexity-reasoning
+
+This tool provides comprehensive research with:
+- Multi-step reasoning
+- Source citations
+- In-depth analysis
+- Fact verification
+
+**Use for:**
+- Complex research questions
+- Technical analysis
+- Fact-checking
+- Comparative studies
+
+**Cost:** ~0.000002-0.000008 🌻 per token (very affordable)`,
+    args: {
+        query: tool.schema.string().describe('Research query or question to investigate'),
+        depth: tool.schema.enum(['quick', 'standard', 'thorough']).optional()
+            .describe('Research depth (default: standard)'),
+    },
+    async execute(args, context) {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            return `❌ Deep Search nécessite une clé API Pollinations.
+🔧 Connectez votre clé avec /pollinations connect`;
+        }
+        const model = 'perplexity-reasoning';
+        const depth = args.depth || 'standard';
+        // Metadata
+        context.metadata({ title: `🔍 Deep Search: ${args.query.substring(0, 50)}...` });
+        try {
+            // Build system prompt based on depth
+            const systemPrompts = {
+                quick: 'Provide a concise but thorough answer with key sources. Be efficient.',
+                standard: 'Provide comprehensive research with analysis, sources, and reasoning steps.',
+                thorough: 'Provide exhaustive research with multiple perspectives, detailed analysis, all relevant sources, and thorough fact-checking. Consider edge cases and alternative viewpoints.',
+            };
+            const { data } = await httpsPost('https://gen.pollinations.ai/v1/chat/completions', {
+                model: model,
+                messages: [
+                    { role: 'system', content: systemPrompts[depth] },
+                    { role: 'user', content: args.query },
+                ],
+                max_tokens: depth === 'thorough' ? 8000 : depth === 'standard' ? 4000 : 2000,
+            }, {
+                'Authorization': `Bearer ${apiKey}`,
+            });
+            const jsonData = JSON.parse(data.toString());
+            const content = jsonData.choices?.[0]?.message?.content || 'No response';
+            // Format result
+            const lines = [
+                `🔍 Deep Search Results`,
+                `━━━━━━━━━━━━━━━━━━`,
+                `Query: ${args.query}`,
+                `Depth: ${depth}`,
+                `Model: ${model}`,
+                ``,
+                content,
+            ];
+            return lines.join('\n');
+        }
+        catch (err) {
+            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+                return `❌ Crédits insuffisants.`;
+            }
+            return `❌ Erreur Deep Search: ${err.message}`;
+        }
+    },
+});

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

@@ -0,0 +1,18 @@
+/**
+ * gen_audio Tool - Pollinations Text-to-Speech
+ *
+ * Updated: 2026-02-12 - Verified API Reference
+ *
+ * Two TTS options:
+ * 1. openai-audio (DEFAULT): GPT-4o Audio Preview - uses /v1/chat/completions with modalities
+ *    - Supports both TTS and STT (Speech-to-Text)
+ *    - Least expensive option
+ *    - Voices: alloy, echo, fable, onyx, nova, shimmer
+ *    - Formats: mp3, wav, pcm16
+ *
+ * 2. elevenlabs: ElevenLabs v3 TTS - uses /audio/{text}
+ *    - 34 expressive voices
+ *    - Higher quality but more expensive
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const genAudioTool: ToolDefinition;

package/dist/tools/pollinations/gen_audio.js

@@ -0,0 +1,204 @@
+/**
+ * gen_audio Tool - Pollinations Text-to-Speech
+ *
+ * Updated: 2026-02-12 - Verified API Reference
+ *
+ * Two TTS options:
+ * 1. openai-audio (DEFAULT): GPT-4o Audio Preview - uses /v1/chat/completions with modalities
+ *    - Supports both TTS and STT (Speech-to-Text)
+ *    - Least expensive option
+ *    - Voices: alloy, echo, fable, onyx, nova, shimmer
+ *    - Formats: mp3, wav, pcm16
+ *
+ * 2. elevenlabs: ElevenLabs v3 TTS - uses /audio/{text}
+ *    - 34 expressive voices
+ *    - Higher quality but more expensive
+ */
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import { getApiKey, httpsPost, ensureDir, generateFilename, getDefaultOutputDir, formatCost, formatFileSize, estimateTtsCost, isCostEstimatorEnabled, AUDIO_MODELS, } from './shared.js';
+// ─── TTS Configuration ────────────────────────────────────────────────────
+const OPENAI_VOICES = ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'];
+const ELEVENLABS_VOICES = [
+    'rachel', 'domi', 'bella', 'elli', 'charlotte', 'dorothy',
+    'sarah', 'emily', 'lily', 'matilda',
+    'adam', 'antoni', 'arnold', 'josh', 'sam', 'daniel',
+    'charlie', 'james', 'fin', 'callum', 'liam', 'george', 'brian', 'bill',
+    'ash', 'ballad', 'coral', 'sage', 'verse',
+];
+const DEFAULT_VOICE = 'alloy';
+const DEFAULT_MODEL = 'openai-audio'; // Changed: openai-audio is now default (least expensive)
+const DEFAULT_FORMAT = 'mp3';
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const genAudioTool = tool({
+    description: `Convert text to speech using Pollinations AI.
+
+**🔊 Models:**
+
+| Model | Type | Voices | Format | Cost | Notes |
+|-------|------|--------|--------|------|-------|
+| openai-audio | TTS + STT | 6 | mp3, wav, pcm16 | Lowest | **DEFAULT** - GPT-4o Audio |
+| elevenlabs | TTS | 34 | mp3, wav, etc. | Higher | Expressive voices |
+
+**🎵 OpenAI Audio (Default, Recommended):**
+- Voices: \`alloy\`, \`echo\`, \`fable\`, \`onyx\`, \`nova\`, \`shimmer\`
+- Formats: \`mp3\` (default), \`wav\`, \`pcm16\`
+- Uses GPT-4o Audio Preview modalities endpoint
+- Lowest cost option
+
+**🎤 ElevenLabs:**
+- 34 expressive voices including: rachel, domi, bella, adam, etc.
+- Higher quality natural-sounding speech
+- More expensive but more expressive
+
+**💡 Tips:**
+- Use \`openai-audio\` for cost-effective TTS
+- Use \`elevenlabs\` for more expressive/character voices
+- For STT (transcription), use the \`transcribe_audio\` tool`,
+    args: {
+        text: tool.schema.string().describe('Text to convert to speech'),
+        voice: tool.schema.string().optional().describe(`Voice to use (default: ${DEFAULT_VOICE})`),
+        model: tool.schema.string().optional().describe(`TTS model (default: ${DEFAULT_MODEL})`),
+        format: tool.schema.enum(['mp3', 'wav', 'pcm16']).optional().describe('Audio format (default: mp3, openai-audio only)'),
+        save_to: tool.schema.string().optional().describe('Custom output directory'),
+        filename: tool.schema.string().optional().describe('Custom filename (without extension)'),
+    },
+    async execute(args, context) {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            return `❌ Le TTS nécessite une clé API Pollinations.
+🔧 Connectez votre clé avec /pollinations connect`;
+        }
+        const text = args.text;
+        const model = args.model || DEFAULT_MODEL;
+        const voice = args.voice || DEFAULT_VOICE;
+        const format = args.format || DEFAULT_FORMAT;
+        // Validate model
+        const modelInfo = AUDIO_MODELS[model];
+        if (!modelInfo) {
+            return `❌ Modèle inconnu: ${model}
+💡 Modèles disponibles: ${Object.keys(AUDIO_MODELS).filter(m => AUDIO_MODELS[m].type === 'tts' || AUDIO_MODELS[m].type === 'both').join(', ')}`;
+        }
+        // Validate voice for selected model
+        if (model === 'openai-audio' && !OPENAI_VOICES.includes(voice)) {
+            return `⚠️ Voix "${voice}" non supportée par openai-audio.
+💡 Voix OpenAI: ${OPENAI_VOICES.join(', ')}`;
+        }
+        if (model === 'elevenlabs' && !ELEVENLABS_VOICES.includes(voice)) {
+            return `⚠️ Voix "${voice}" non reconnue pour elevenlabs.
+💡 Voix ElevenLabs populaires: rachel, domi, bella, adam, josh...
+📋 Total: ${ELEVENLABS_VOICES.length} voix disponibles`;
+        }
+        // Estimate cost
+        const estimatedCost = estimateTtsCost(text.length);
+        // Metadata
+        context.metadata({ title: `🔊 TTS: ${voice} (${text.length} chars)` });
+        try {
+            let audioData;
+            let responseHeaders = {};
+            let actualFormat = format;
+            if (model === 'openai-audio') {
+                // === OpenAI Audio: Use modalities endpoint ===
+                // POST /v1/chat/completions with audio modalities
+                const response = await httpsPost('https://gen.pollinations.ai/v1/chat/completions', {
+                    model: 'openai-audio',
+                    modalities: ['text', 'audio'],
+                    audio: {
+                        voice: voice,
+                        format: format,
+                    },
+                    messages: [
+                        {
+                            role: 'user',
+                            content: text
+                        }
+                    ],
+                }, {
+                    'Authorization': `Bearer ${apiKey}`,
+                });
+                const data = JSON.parse(response.data.toString());
+                // Extract audio from response
+                const audioBase64 = data.choices?.[0]?.message?.audio?.data;
+                if (!audioBase64) {
+                    throw new Error('No audio data in response');
+                }
+                audioData = Buffer.from(audioBase64, 'base64');
+                responseHeaders = response.headers;
+            }
+            else if (model === 'elevenlabs') {
+                // === ElevenLabs: Use audio endpoint ===
+                // GET/POST /audio/{text}
+                const promptEncoded = encodeURIComponent(text);
+                const url = `https://gen.pollinations.ai/audio/${promptEncoded}?model=elevenlabs&voice=${voice}`;
+                // For elevenlabs, we might need a different approach
+                // Let's use POST with JSON body
+                const response = await httpsPost('https://gen.pollinations.ai/v1/audio/speech', {
+                    model: 'elevenlabs',
+                    input: text,
+                    voice: voice,
+                }, {
+                    'Authorization': `Bearer ${apiKey}`,
+                });
+                // Check if response is JSON (error) or binary (audio)
+                const contentType = response.headers['content-type'] || '';
+                if (contentType.includes('application/json')) {
+                    const data = JSON.parse(response.data.toString());
+                    throw new Error(data.error?.message || 'Unknown error');
+                }
+                audioData = response.data;
+                responseHeaders = response.headers;
+            }
+            else {
+                // Fallback to OpenAI-compatible endpoint
+                const response = await httpsPost('https://gen.pollinations.ai/v1/audio/speech', {
+                    model: model,
+                    input: text,
+                    voice: voice,
+                }, {
+                    'Authorization': `Bearer ${apiKey}`,
+                });
+                audioData = response.data;
+                responseHeaders = response.headers;
+            }
+            // Save audio
+            const outputDir = args.save_to || getDefaultOutputDir('audio');
+            ensureDir(outputDir);
+            const filename = args.filename || generateFilename('tts', `${model}_${voice}`, actualFormat);
+            const filePath = path.join(outputDir, filename.endsWith(`.${actualFormat}`) ? filename : `${filename}.${actualFormat}`);
+            fs.writeFileSync(filePath, audioData);
+            const fileSize = fs.statSync(filePath).size;
+            // Estimate duration (approx 15 chars per second for speech)
+            const estimatedDuration = Math.ceil(text.length / 15);
+            // Build result
+            const lines = [
+                `🔊 Audio Généré (TTS)`,
+                `━━━━━━━━━━━━━━━━━━`,
+                `Texte: "${text.substring(0, 60)}${text.length > 60 ? '...' : ''}"`,
+                `Modèle: ${model}${model === 'openai-audio' ? ' (recommandé)' : ''}`,
+                `Voix: ${voice}`,
+                `Format: ${actualFormat}`,
+                `Durée estimée: ~${estimatedDuration}s`,
+                `Fichier: ${filePath}`,
+                `Taille: ${formatFileSize(fileSize)}`,
+            ];
+            // Cost info
+            if (isCostEstimatorEnabled()) {
+                lines.push(`Coût estimé: ${formatCost(estimatedCost)}`);
+            }
+            if (responseHeaders['x-request-id']) {
+                lines.push(`Request ID: ${responseHeaders['x-request-id']}`);
+            }
+            return lines.join('\n');
+        }
+        catch (err) {
+            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+                return `❌ Crédits insuffisants.`;
+            }
+            if (err.message?.includes('401') || err.message?.includes('403')) {
+                return `❌ Clé API invalide ou non autorisée.`;
+            }
+            return `❌ Erreur TTS: ${err.message}`;
+        }
+    },
+});

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

@@ -0,0 +1,13 @@
+/**
+ * gen_image Tool - Pollinations Image Generation
+ *
+ * Updated: 2026-02-12 - Verified API Reference
+ *
+ * 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)
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const genImageTool: ToolDefinition;

package/dist/tools/pollinations/gen_image.js

@@ -0,0 +1,239 @@
+/**
+ * gen_image Tool - Pollinations Image Generation
+ *
+ * Updated: 2026-02-12 - Verified API Reference
+ *
+ * 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)
+ */
+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';
+// ─── 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({
+    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
+
+**⚙️ 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)`,
+    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)'),
+        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)'),
+        seed: tool.schema.number().optional().describe('Seed for reproducibility (-1 for random)'),
+        quality: tool.schema.enum(['low', 'med', 'high']).optional().describe('Quality for gptimage models only'),
+        transparent: tool.schema.boolean().optional().describe('Transparent background for gptimage models only'),
+        save_to: tool.schema.string().optional().describe('Custom output directory'),
+        filename: tool.schema.string().optional().describe('Custom filename (without extension)'),
+    },
+    async execute(args, context) {
+        const apiKey = getApiKey();
+        const hasKey = hasApiKey();
+        // Determine model based on key presence
+        let model = args.model || (hasKey ? DEFAULT_MODEL : FREE_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...` : ''}`;
+        }
+        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`;
+        }
+        // Validate I2I support
+        if (args.reference_image && isPaidModel && !supportsI2I(model)) {
+            return `⚠️ Le modèle "${model}" ne supporte pas l'Image-to-Image.
+💡 Modèles I2I supportés: ${Object.entries(PAID_IMAGE_MODELS)
+                .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;
+        // Set metadata
+        context.metadata({ title: `🎨 Image: ${model}` });
+        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;
+            }
+            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.
+💡 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));
+                }
+                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'];
+                }
+            }
+            // 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`);
+            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
+            }
+            // 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}`,
+            ];
+            // 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']}`);
+                }
+            }
+            return lines.join('\n');
+        }
+        catch (err) {
+            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(', ')}`;
+            }
+            if (err.message?.includes('401') || err.message?.includes('403')) {
+                return `❌ Clé API invalide ou non autorisée.
+🔧 Vérifiez votre clé avec /pollinations connect`;
+            }
+            if (err.message?.includes('400')) {
+                return `❌ Paramètres invalides: ${err.message}
+💡 Vérifiez que le modèle supporte les paramètres fournis.`;
+            }
+            return `❌ Erreur génération image: ${err.message}`;
+        }
+    },
+});

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

@@ -0,0 +1,14 @@
+/**
+ * gen_music Tool - Pollinations Music Generation
+ *
+ * Updated: 2026-02-12 - Verified API Reference
+ *
+ * Model: elevenmusic (ElevenLabs Music)
+ * Endpoint: gen.pollinations.ai/audio/{text}
+ *
+ * Parameters:
+ * - duration: 3-300 seconds
+ * - instrumental: boolean (vocals or instrumental only)
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const genMusicTool: ToolDefinition;