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

package/dist/tools/pollinations/gen_image.js

@@ -0,0 +1,211 @@
+/**
+ * gen_image Tool - Pollinations Image Generation
+ *
+ * Updated: 2026-02-19 - Dynamic ModelRegistry + Cost Guard + Toasts
+ *
+ * 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, extractCostFromHeaders, isCostEstimatorEnabled, supportsI2I, getPaidImageModels, fetchEnterBalance, sanitizeFilename, validateHttpUrl, } from './shared.js';
+import { loadConfig } from '../../server/config.js';
+import { checkCostControl, isTokenBased } from './cost-guard.js';
+import { emitStatusToast } from '../../server/toast.js';
+import { t } from '../../locales/index.js';
+// ─── Constants ─────────────────────────────────────────────────────────────
+const DEFAULT_MODEL = 'flux';
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const polliGenImageTool = tool({
+    description: t('tools.image.desc'),
+    args: {
+        prompt: tool.schema.string().describe(t('tools.image.arg_prompt')),
+        model: tool.schema.string().describe(t('tools.image.arg_model')),
+        width: tool.schema.number().min(256).max(4096).optional().describe(t('tools.image.arg_width')),
+        height: tool.schema.number().min(256).max(4096).optional().describe(t('tools.image.arg_height')),
+        reference_image: tool.schema.string().optional().describe(t('tools.image.arg_ref')),
+        seed: tool.schema.number().optional().describe(t('tools.image.arg_seed')),
+        quality: tool.schema.enum(['low', 'med', 'high']).optional().describe(t('tools.image.arg_quality')),
+        transparent: tool.schema.boolean().optional().describe(t('tools.image.arg_trans')),
+        save_to: tool.schema.string().optional().describe(t('tools.image.arg_save_to')),
+        filename: tool.schema.string().optional().describe(t('tools.image.arg_filename')),
+    },
+    async execute(args, context) {
+        const apiKey = getApiKey();
+        const hasKey = hasApiKey();
+        // Determine model based on key presence
+        let model = args.model;
+        const width = args.width || 1024;
+        const height = args.height || 1024;
+        // 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 t('tools.image.req_key', { models: Object.keys(imageModels).slice(0, 5).join(', ') });
+        }
+        // Unknown model → beta passthrough (don't reject)
+        if (isBetaModel) {
+            emitStatusToast('warning', t('tools.image.unreferenced_model', { model }), '🎨 gen_image');
+        }
+        // Validate I2I support (for known models only; beta models get default behavior)
+        if (args.reference_image) {
+            if (!validateHttpUrl(args.reference_image)) {
+                return t('tools.image.req_url_i2i') || '❌ URL invalide. Utilisez http:// ou https://';
+            }
+            if (knownModel && !supportsI2I(model)) {
+                const models = Object.entries(imageModels)
+                    .filter(([, info]) => info.i2i)
+                    .map(([name]) => name)
+                    .join(', ');
+                return t('tools.image.no_i2i', { model, models });
+            }
+        }
+        // Estimate cost
+        const estimatedCost = estimateImageCost(model);
+        // Cost Guard check V2
+        const costCheck = checkCostControl('polli_gen_image', args, model, estimatedCost, 'image');
+        if (!costCheck.allowed) {
+            return costCheck.message || t('tools.image.blocked');
+        }
+        // Emit start toast
+        const config = loadConfig();
+        const argsStr = config.gui?.logs === 'verbose' ? `\nParameters: ${JSON.stringify(args)}` : '';
+        emitStatusToast('info', t('tools.image.generating', { model, width, height }) + argsStr, '🎨 polli_gen_image');
+        // Set metadata
+        context.metadata({ title: `🎨 Image: ${model}${isBetaModel ? ' (beta)' : ''}` });
+        try {
+            let imageData;
+            let responseHeaders = {};
+            let usedModel = model;
+            // === 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));
+            }
+            // I2I: reference image(s)
+            if (args.reference_image) {
+                params.set('image', args.reference_image);
+            }
+            // 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 ? sanitizeFilename(args.filename) : undefined;
+            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);
+                }
+                else {
+                    outputDir = args.save_to;
+                }
+            }
+            ensureDir(outputDir);
+            filename = filename || generateFilename('image', usedModel, 'png');
+            const filePath = path.join(outputDir, filename.includes('.') ? filename : `${filename}.png`);
+            fs.writeFileSync(filePath, imageData);
+            // 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 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(t('tools.image.res_title'));
+            lines.push(`━━━━━━━━━━━━━━━━━━`);
+            lines.push(t('tools.image.res_prompt', { prompt: args.prompt.substring(0, 100) + (args.prompt.length > 100 ? '...' : '') }));
+            lines.push(t('tools.image.res_model', { model: `${usedModel}${isBetaModel ? ' (beta)' : ''}` }));
+            lines.push(t('tools.image.res_res', { width, height }));
+            // Add I2I info if used
+            if (args.reference_image) {
+                lines.push(t('tools.image.res_i2i_src', { src: args.reference_image.substring(0, 50) + '...' }));
+            }
+            lines.push(t('tools.image.res_file', { path: filePath }));
+            lines.push(t('tools.image.res_size', { size: formatFileSize(fileSize) }));
+            // Pricing details (Estimé vs Réel)
+            if (isCostEstimatorEnabled()) {
+                const maxCost = estimatedCost * 3;
+                lines.push(t('tools.image.cost_title'));
+                if (isTokenBased('image', usedModel)) {
+                    lines.push(`- Cost   : ${formatCost(estimatedCost)} (Max théorique: ${formatCost(maxCost)})`);
+                }
+                else {
+                    lines.push(t('tools.image.cost_estimated', { cost: formatCost(estimatedCost) }));
+                }
+                if (realCost !== undefined) {
+                    lines.push(t('tools.image.cost_real_wallet', { cost: formatCost(realCost) }));
+                }
+                else if (costTracking.costUsd !== undefined) {
+                    lines.push(t('tools.image.cost_real_api', { cost: formatCost(costTracking.costUsd) }));
+                }
+                else {
+                    lines.push(t('tools.image.cost_unknown'));
+                }
+            }
+            if (responseHeaders['x-request-id']) {
+                lines.push(`Request ID: ${responseHeaders['x-request-id']}`);
+            }
+            // Emit success toast
+            emitStatusToast('success', t('tools.image.success', { model: usedModel }), '🎨 gen_image', { filePath: filePath });
+            return lines.join('\n');
+        }
+        catch (err) {
+            emitStatusToast('error', t('tools.image.error', { error: err.message?.substring(0, 60) }), '🎨 gen_image');
+            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+                return t('tools.image.insufficient_funds', { model });
+            }
+            if (err.message?.includes('401') || err.message?.includes('403')) {
+                return t('tools.image.invalid_key');
+            }
+            if (err.message?.includes('400')) {
+                return t('tools.image.invalid_params', { error: err.message });
+            }
+            return t('tools.image.gen_error_msg', { error: 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 polliGenMusicTool: ToolDefinition;

package/dist/tools/pollinations/gen_music.js

@@ -0,0 +1,157 @@
+/**
+ * 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 { 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, extractCostFromHeaders, isCostEstimatorEnabled, sanitizeFilename, } from './shared.js';
+import { loadConfig } from '../../server/config.js';
+import { checkCostControl, isTokenBased } from './cost-guard.js';
+import { emitStatusToast } from '../../server/toast.js';
+import { t } from '../../locales/index.js';
+// ─── Constants ─────────────────────────────────────────────────────────────
+const DEFAULT_DURATION = 10;
+const MODEL_NAME = 'elevenmusic';
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const polliGenMusicTool = tool({
+    description: t('tools.polli_gen_music.desc'),
+    args: {
+        prompt: tool.schema.string().describe(t('tools.polli_gen_music.arg_prompt')),
+        duration: tool.schema.number().optional()
+            .describe(t('tools.polli_gen_music.arg_duration', { default: DEFAULT_DURATION, max: 300 })),
+        instrumental: tool.schema.boolean().optional().describe(t('tools.polli_gen_music.arg_instrumental')),
+        seed: tool.schema.number().optional().describe(t('tools.polli_gen_music.arg_seed')),
+        save_to: tool.schema.string().optional().describe(t('tools.polli_gen_music.arg_save_to')),
+        filename: tool.schema.string().optional().describe(t('tools.polli_gen_music.arg_filename')),
+    },
+    async execute(args, context) {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            return t('tools.polli_gen_music.req_key');
+        }
+        // Get dynamic range from ModelRegistry (populated via OpenAPI)
+        const { getMusicModel } = await import('./shared.js');
+        const modelConfig = getMusicModel()[MODEL_NAME];
+        const [minDuration, maxDuration] = modelConfig?.duration || [3, 300];
+        const duration = Math.min(Math.max(args.duration || DEFAULT_DURATION, minDuration), maxDuration);
+        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 || t('tools.polli_gen_music.blocked');
+        }
+        // Estimate generation time
+        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', t('tools.polli_gen_music.toast_start', { duration, time: genTimeSeconds }) + argsStr, '🎵 polli_gen_music');
+        // Metadata
+        context.metadata({ title: `🎵 Music: ${duration}s (~${genTimeSeconds}s gen time)` });
+        try {
+            // Build URL
+            const params = new URLSearchParams({
+                model: MODEL_NAME,
+                nologo: 'true',
+                private: 'true',
+                duration: String(duration),
+            });
+            if (instrumental) {
+                params.set('instrumental', 'true');
+            }
+            // Seed for reproducibility
+            if (args.seed !== undefined) {
+                params.set('seed', String(args.seed));
+            }
+            const promptEncoded = encodeURIComponent(args.prompt);
+            const url = `https://gen.pollinations.ai/audio/${promptEncoded}?${params}`;
+            const headers = {
+                'Authorization': `Bearer ${apiKey}`,
+            };
+            // Music generation takes time
+            const result = await httpsGet(url, headers);
+            const audioData = result.data;
+            const responseHeaders = result.headers;
+            // Save audio
+            let outputDir = getDefaultOutputDir('music');
+            let filename = args.filename ? sanitizeFilename(args.filename) : undefined;
+            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);
+            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 = [];
+            // Inject costWarning at top if present
+            if (costCheck.message && !costCheck.allowed) {
+                lines.push(costCheck.message);
+                lines.push('');
+            }
+            lines.push(t('tools.polli_gen_music.res_title'));
+            lines.push(`━━━━━━━━━━━━━━━━━━`);
+            lines.push(t('tools.polli_gen_music.res_prompt', { prompt: args.prompt }));
+            lines.push(t('tools.polli_gen_music.res_duration', { duration }));
+            lines.push(t('tools.polli_gen_music.res_mode', { mode: instrumental ? t('tools.polli_gen_music.res_mode_inst') : t('tools.polli_gen_music.res_mode_vocal') }));
+            lines.push(t('tools.polli_gen_music.res_file', { path: filePath }));
+            lines.push(t('tools.polli_gen_music.res_size', { size: formatFileSize(fileSize) }));
+            // Cost info
+            if (isCostEstimatorEnabled()) {
+                if (isTokenBased('audio', MODEL_NAME)) {
+                    const maxCost = estimatedCost * 3;
+                    lines.push(t('tools.polli_gen_music.res_cost_tok', { cost: formatCost(actualCost), maxCost: formatCost(maxCost) }));
+                }
+                else {
+                    lines.push(t('tools.polli_gen_music.res_cost', { cost: formatCost(actualCost) }));
+                }
+            }
+            if (responseHeaders['x-model-used']) {
+                lines.push(t('tools.polli_gen_music.res_model_used', { model: responseHeaders['x-model-used'] }));
+            }
+            if (responseHeaders['x-request-id']) {
+                lines.push(t('tools.polli_gen_music.res_request_id', { id: responseHeaders['x-request-id'] }));
+            }
+            // Emit success toast
+            emitStatusToast('success', t('tools.polli_gen_music.toast_success', { duration }), '🎵 gen_music');
+            return lines.join('\n');
+        }
+        catch (err) {
+            emitStatusToast('error', t('tools.polli_gen_music.toast_err', { error: err.message?.substring(0, 60) }), '🎵 gen_music');
+            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+                return t('tools.polli_gen_music.err_pollen');
+            }
+            if (err.message?.includes('401') || err.message?.includes('403')) {
+                return t('tools.polli_gen_music.err_auth');
+            }
+            if (err.message?.includes('Timeout')) {
+                return t('tools.polli_gen_music.err_timeout');
+            }
+            return t('tools.polli_gen_music.err_gen', { error: err.message });
+        }
+    },
+});

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

@@ -0,0 +1,16 @@
+/**
+ * gen_video Tool - Pollinations Video Generation
+ *
+ * Updated: 2026-02-12 - Verified API Reference
+ *
+ * Video models with different capabilities:
+ * - T2V (Text-to-Video): grok-video, ltx-2, veo, seedance, seedance-pro
+ * - I2V (Image-to-Video): wan (I2V ONLY!), veo, seedance, seedance-pro
+ * - Veo Interpolation: Uses image=url1,url2 for transitions
+ *
+ * Response headers for cost tracking:
+ * - x-usage-completion-video-seconds (grok, ltx-2, veo, wan)
+ * - x-usage-completion-video-tokens (seedance, seedance-pro)
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const polliGenVideoTool: ToolDefinition;

package/dist/tools/pollinations/gen_video.js

@@ -0,0 +1,249 @@
+/**
+ * gen_video Tool - Pollinations Video Generation
+ *
+ * Updated: 2026-02-12 - Verified API Reference
+ *
+ * Video models with different capabilities:
+ * - T2V (Text-to-Video): grok-video, ltx-2, veo, seedance, seedance-pro
+ * - I2V (Image-to-Video): wan (I2V ONLY!), veo, seedance, seedance-pro
+ * - Veo Interpolation: Uses image=url1,url2 for transitions
+ *
+ * Response headers for cost tracking:
+ * - x-usage-completion-video-seconds (grok, ltx-2, veo, wan)
+ * - x-usage-completion-video-tokens (seedance, seedance-pro)
+ */
+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, estimateVideoCost, extractCostFromHeaders, isCostEstimatorEnabled, supportsI2V, requiresI2V, validateAspectRatio, getDurationRange, getVideoModels, fetchEnterBalance, sanitizeFilename, validateHttpUrl, } from './shared.js';
+import { loadConfig } from '../../server/config.js';
+import { checkCostControl, isTokenBased } from './cost-guard.js';
+import { emitStatusToast } from '../../server/toast.js';
+import { t } from '../../locales/index.js';
+// ─── Constants ─────────────────────────────────────────────────────────────
+const CHEAPEST_MODEL = 'grok-video';
+const DEFAULT_DURATION = 3;
+const DEFAULT_ASPECT_RATIO = '16:9';
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const polliGenVideoTool = tool({
+    description: t('tools.polli_gen_video.desc'),
+    args: {
+        prompt: tool.schema.string().describe(t('tools.polli_gen_video.arg_prompt')),
+        model: tool.schema.string().describe(t('tools.polli_gen_video.arg_model', { model: CHEAPEST_MODEL })),
+        duration: tool.schema.number().optional().describe(t('tools.polli_gen_video.arg_duration')),
+        aspect_ratio: tool.schema.enum(['16:9', '9:16', '1:1', '4:3']).optional().describe(t('tools.polli_gen_video.arg_aspect')),
+        reference_image: tool.schema.string().optional().describe(t('tools.polli_gen_video.arg_ref')),
+        seed: tool.schema.number().optional().describe(t('tools.polli_gen_video.arg_seed')),
+        save_to: tool.schema.string().optional().describe(t('tools.polli_gen_video.arg_save_to')),
+        filename: tool.schema.string().optional().describe(t('tools.polli_gen_video.arg_filename')),
+    },
+    async execute(args, context) {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            return t('tools.polli_gen_video.req_key');
+        }
+        const model = args.model;
+        const aspectRatio = args.aspect_ratio || DEFAULT_ASPECT_RATIO;
+        // Get model config from dynamic registry
+        const videoModels = getVideoModels();
+        const modelConfig = videoModels[model];
+        const isBetaModel = !modelConfig;
+        if (isBetaModel) {
+            emitStatusToast('warning', t('tools.polli_gen_video.warn_beta', { model }), '🎬 gen_video');
+        }
+        // Validate duration (for known models; beta models use defaults)
+        const [minDuration, maxDuration] = isBetaModel ? [1, 20] : getDurationRange(model);
+        const duration = args.duration || Math.min(DEFAULT_DURATION, maxDuration);
+        if (duration < minDuration || duration > maxDuration) {
+            return t('tools.polli_gen_video.invalid_duration', { model, duration, min: minDuration, max: maxDuration });
+        }
+        // Validate aspect ratio (for known models; beta models accept any)
+        if (!isBetaModel && !validateAspectRatio(model, aspectRatio)) {
+            return t('tools.polli_gen_video.invalid_aspect', { model, aspect: aspectRatio, supported: modelConfig.aspectRatios.join(', ') });
+        }
+        // Check I2V requirements & validation
+        if (args.reference_image) {
+            const urls = args.reference_image.split(',').map(u => u.trim());
+            for (const u of urls) {
+                if (!validateHttpUrl(u)) {
+                    return '❌ URL invalide. Utilisez http:// ou https://';
+                }
+            }
+        }
+        const requiresReferenceImage = !isBetaModel && requiresI2V(model);
+        const supportsReferenceImage = isBetaModel || supportsI2V(model);
+        if (requiresReferenceImage && !args.reference_image) {
+            return t('tools.polli_gen_video.req_i2v', { model });
+        }
+        if (args.reference_image && !supportsReferenceImage) {
+            const models = Object.entries(videoModels)
+                .filter(([, info]) => info.i2v)
+                .map(([name]) => name)
+                .join(', ');
+            return t('tools.polli_gen_video.no_i2v', { model, models });
+        }
+        // Estimate cost
+        const estimatedCost = estimateVideoCost(model, duration);
+        // Cost Guard check V2
+        const costCheck = checkCostControl('polli_gen_video', args, model, estimatedCost, 'video');
+        if (!costCheck.allowed) {
+            return costCheck.message || t('tools.polli_gen_video.blocked');
+        }
+        // Emit start toast
+        const config = loadConfig();
+        const argsStr = config.gui?.logs === 'verbose' ? `\nParameters: ${JSON.stringify(args)}` : '';
+        emitStatusToast('info', t('tools.polli_gen_video.toast_start', { model, duration }) + argsStr, '🎬 polli_gen_video');
+        // Metadata
+        context.metadata({ title: `🎬 Video: ${model}${isBetaModel ? ' (beta)' : ''} (${duration}s)` });
+        try {
+            // Build URL
+            const params = new URLSearchParams({
+                model: model,
+                nologo: 'true',
+                private: 'true',
+            });
+            // Duration parameter
+            params.set('duration', String(duration));
+            // Aspect ratio - convert to width/height for API
+            const aspectToSize = {
+                '16:9': { w: 1920, h: 1080 },
+                '9:16': { w: 1080, h: 1920 },
+                '1:1': { w: 1024, h: 1024 },
+                '4:3': { w: 1440, h: 1080 },
+            };
+            const size = aspectToSize[aspectRatio] || aspectToSize['16:9'];
+            params.set('width', String(size.w));
+            params.set('height', String(size.h));
+            // I2V: reference image(s)
+            if (args.reference_image) {
+                // Veo interpolation: comma-separated URLs
+                // Other I2V models: single URL
+                params.set('image', args.reference_image);
+            }
+            // Seed for reproducibility
+            if (args.seed !== undefined) {
+                params.set('seed', String(args.seed));
+            }
+            const promptEncoded = encodeURIComponent(args.prompt);
+            const url = `https://gen.pollinations.ai/image/${promptEncoded}?${params}`;
+            const headers = {
+                'Authorization': `Bearer ${apiKey}`,
+            };
+            // 1. Fetch balance avant génération
+            const balBefore = await fetchEnterBalance();
+            // Video generation takes time (30-70 seconds depending on model)
+            const result = await httpsGet(url, headers);
+            const videoData = result.data;
+            const responseHeaders = result.headers;
+            // Save video
+            let outputDir = getDefaultOutputDir('videos');
+            let filename = args.filename ? sanitizeFilename(args.filename) : undefined;
+            if (args.save_to) {
+                if (args.save_to.match(/\.(mp4|webm|mov|avi)$/i)) {
+                    outputDir = path.dirname(args.save_to);
+                    filename = path.basename(args.save_to);
+                }
+                else {
+                    outputDir = args.save_to;
+                }
+            }
+            ensureDir(outputDir);
+            filename = filename || generateFilename('video', model, 'mp4');
+            const filePath = path.join(outputDir, filename.endsWith('.mp4') ? filename : `${filename}.mp4`);
+            fs.writeFileSync(filePath, videoData);
+            const fileSize = fs.statSync(filePath).size;
+            // Extract actual cost from headers as fallback
+            const costTracking = extractCostFromHeaders(responseHeaders);
+            // 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;
+                }
+            }
+            // Build result
+            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(t('tools.polli_gen_video.res_title'));
+            lines.push(`━━━━━━━━━━━━━━━━━━`);
+            lines.push(t('tools.polli_gen_video.res_prompt', { prompt: args.prompt.substring(0, 80) + (args.prompt.length > 80 ? '...' : '') }));
+            lines.push(t('tools.polli_gen_video.res_model', { model: `${model}${isBetaModel ? ' (beta)' : ''}${modelConfig?.cost?.includes('💎') ? ' 💎' : ''}` }));
+            lines.push(t('tools.polli_gen_video.res_duration', { duration }));
+            lines.push(t('tools.polli_gen_video.res_aspect', { aspect: aspectRatio }));
+            // Add I2V info if used
+            if (args.reference_image) {
+                const isInterpolation = model === 'veo' && args.reference_image.includes(',');
+                lines.push(t('tools.polli_gen_video.res_i2v_mode', { mode: isInterpolation ? t('tools.polli_gen_video.res_i2v_interp') : t('tools.polli_gen_video.res_i2v_single') }));
+                lines.push(t('tools.polli_gen_video.res_source', { url: args.reference_image.substring(0, 50) + '...' }));
+            }
+            // Audio info (known models only)
+            if (modelConfig?.audio) {
+                lines.push(t('tools.polli_gen_video.res_audio_ok'));
+            }
+            else if (!isBetaModel) {
+                lines.push(t('tools.polli_gen_video.res_audio_no'));
+            }
+            lines.push(t('tools.polli_gen_video.res_file', { path: filePath }));
+            lines.push(t('tools.polli_gen_video.res_size', { size: formatFileSize(fileSize) }));
+            // Pricing details (Estimé vs Réel)
+            if (isCostEstimatorEnabled()) {
+                const maxCost = estimatedCost * 3;
+                lines.push(t('tools.polli_gen_video.res_cost_title'));
+                if (isTokenBased('video', model)) {
+                    lines.push(t('tools.polli_gen_video.res_cost_est_tok', { cost: formatCost(estimatedCost), maxCost: formatCost(maxCost) }));
+                }
+                else {
+                    lines.push(t('tools.polli_gen_video.res_cost_est', { cost: formatCost(estimatedCost) }));
+                }
+                if (realCost !== undefined) {
+                    lines.push(t('tools.polli_gen_video.res_cost_real_wallet', { cost: formatCost(realCost) }));
+                }
+                else if (costTracking.costUsd !== undefined) {
+                    lines.push(t('tools.polli_gen_video.res_cost_real_headers', { cost: formatCost(costTracking.costUsd) }));
+                }
+                else {
+                    lines.push(t('tools.polli_gen_video.res_cost_real_unknown'));
+                }
+            }
+            if (responseHeaders['x-model-used']) {
+                lines.push(t('tools.polli_gen_video.res_model_used', { model: responseHeaders['x-model-used'] }));
+            }
+            if (responseHeaders['x-request-id']) {
+                lines.push(t('tools.polli_gen_video.res_request_id', { id: responseHeaders['x-request-id'] }));
+            }
+            // Gen time estimate (known models only)
+            if (modelConfig?.genTime) {
+                lines.push(t('tools.polli_gen_video.res_time', { time: modelConfig.genTime }));
+            }
+            // Emit success toast
+            emitStatusToast('success', t('tools.polli_gen_video.toast_success', { model, duration }), '🎬 gen_video');
+            return lines.join('\n');
+        }
+        catch (err) {
+            emitStatusToast('error', t('tools.polli_gen_video.toast_err', { error: err.message?.substring(0, 60) }), '🎬 gen_video');
+            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+                return t('tools.polli_gen_video.err_pollen');
+            }
+            if (err.message?.includes('400')) {
+                if (requiresI2V(model) && !args.reference_image) {
+                    return t('tools.polli_gen_video.err_i2v_req', { model });
+                }
+                return t('tools.polli_gen_video.err_invalid', { msg: err.message });
+            }
+            if (err.message?.includes('520') && model === 'ltx-2') {
+                return t('tools.polli_gen_video.err_520');
+            }
+            if (err.message?.includes('Timeout')) {
+                return t('tools.polli_gen_video.err_timeout');
+            }
+            return t('tools.polli_gen_video.err_gen', { error: err.message });
+        }
+    },
+});

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

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const polliConfigTool: ToolDefinition;